OFFICIAL DOCUMENTATION

AutoTrain Engine

Upload datasets, train tabular machine-learning models, import existing models, evaluate predictions, and connect production applications to stable prediction endpoints.

Base URL: https://api.autotrain.app. Model management is performed from the AutoTrain dashboard. Paid plans display the endpoint assigned to each testing tab.

Standard workflow

  1. Sign in and upload a dataset or choose Bring Your Own Model.
  2. Configure preprocessing, task, target, and model parameters.
  3. Train or upload the model and create a Model Testing tab.
  4. Validate single or batch predictions.
  5. On Basic or Advanced, use the endpoint shown in Testing Console from your application.

Task guides

Tabular classificationTargets, preprocessing, metrics, and new-row testing.
RegressionLeakage-safe splits, metrics, and residual checks.
ClusteringFeature scaling, cluster comparison, and interpretation.
Model comparisonCompare runs fairly and document selection decisions.
Model exportPreserve preprocessing, schemas, and compatibility.
Prediction APIsInspect schemas and call tabular or image endpoints.

Use cases and dataset references

Use the public experiment library to see how a decision question becomes a target, preprocessing plan, fixed benchmark, interpretation, and limitation review. Dataset pages then connect the source fields to the matching AutoTrain guide.

Use case libraryChurn, house prices, student performance, obesity risk, and customer segmentation.
Dataset catalogTask, target, source terms, preparation checks, and research context.
Product workflowWhat AutoTrain saves, supports, tests, exports, and leaves under user control.

Supported models

TabularClassification, regression, and clustering. Joblib, PKL, and Pickle BYOM files.
ImageONNX, Keras, TFLite, frozen GraphDef, and SavedModel files for classification, segmentation, and object detection.
ExportsDownload trained artifacts and use the prediction schema to inspect expected inputs.

Image model files

Complete .onnx, .keras, .h5, and .tflite models are inspected automatically. A .pb upload must be a frozen GraphDef with one image input and a terminal output. Upload a SavedModel directory as a .tf or .zip archive containing saved_model.pb and its variables directory.

An H5 file created with model.save_weights() must be paired with the matching architecture JSON exported by model.to_json(). For a single portable Keras artifact, export with model.save("model.keras").

Image preprocessing

Image models support a fixed input width and height, 1/3/4 channels, RGB/BGR/grayscale color mode, and pixel ranges of 0–1, -1–1, or original values. These settings must match model training.

Tabular prediction

POST/api/autotrain/jobs/{job_id}/predict
curl -X POST "https://api.autotrain.app/api/autotrain/jobs/JOB_ID/predict" \
  -H "Content-Type: application/json" \
  -d '{"data":[{"age":42,"income":58000}]}'
{
  "success": true,
  "task": "classification",
  "predictions": [{
    "predicted_class": "approved",
    "confidence_score": 0.94,
    "probabilities": {"approved": 0.94, "rejected": 0.06}
  }]
}

Input schema

GET/api/autotrain/jobs/{job_id}/schema

The schema returns feature columns, task, model type, target column, request format, and output fields.

Image prediction

POST/api/autotrain/jobs/{job_id}/predict-image
curl -X POST "https://api.autotrain.app/api/autotrain/jobs/JOB_ID/predict-image" \
  -F "file=@sample.jpg"

Accepted browser formats are PNG, JPEG, and WebP. The response depends on the image task.

Image segmentation

Single-class masks use a transparent red overlay by default. Multiclass colors can be configured in Testing Console and are sent as a JSON array in the optional class_colors form field.

curl -X POST "https://api.autotrain.app/api/autotrain/jobs/JOB_ID/predict-image" \
  -F "file=@sample.jpg" \
  -F 'class_colors=["#ef4444","#22c55e","#3b82f6"]'
FieldDescription
mask_pngBase64 PNG segmentation mask.
overlay_pngBase64 PNG mask composited over the input.
class_countsPixel count per output class.
confidenceMean highest pixel probability.

Image classification

The response returns the detected class, class index, confidence, and either a label-to-probability object or score array. Provide class labels when importing a model to receive named results.

{"predicted_class":"cat","class_index":1,"confidence":0.982,"probabilities":{"dog":0.018,"cat":0.982}}

Object detection

Detection models must expose one decoded output tensor with shape [batch, detections, 6]. Each row is:

[x1, y1, x2, y2, confidence, class_id]

Coordinates may be normalized to 0–1 or expressed in model-input pixels. A single-box model may return [batch, 4]. Detections below 25% confidence are omitted.

{
  "annotated_png": "data:image/png;base64,...",
  "detection_count": 1,
  "detections": [{"class_name":"person","confidence":0.97,"box":[31,18,210,248]}]
}

External deployment platforms

AutoTrain Engine provides managed training, testing, exports, and prediction endpoints. When a project needs a public demo, dedicated GPU, custom serving stack, or a third-party computer-vision workflow, the exported model can also be deployed through a specialized provider.

Choose by workload, not brand. Demo hosting, production inference, raw GPU infrastructure, and end-to-end computer vision solve different operational problems. External provider pricing and features can change; verify current terms before deployment.
INTERACTIVE DEMOS

Hugging Face Spaces / Gradio

Best for public or private ML demos built with Gradio, Streamlit, static apps, or Docker.

  • Free basic CPU option and optional GPU upgrades.
  • Direct Hugging Face Hub, secrets, and community integration.
  • Designed for demos and prototypes; sleep and cold starts may occur.
Visit Hugging Face Spaces
MANAGED API

Hugging Face Inference Endpoints

Best for serving a Hub or custom model through a dedicated production API.

  • CPU/GPU selection, autoscaling, private endpoints, and monitoring.
  • Natural choice when artifacts already live on Hugging Face Hub.
  • More managed than raw GPU hosting, with higher baseline cost.
Visit Inference Endpoints
MODEL API

Replicate

Best for quickly exposing generative, image, video, audio, or custom models as APIs.

  • Public model catalog, model versions, webhooks, and per-second compute billing.
  • Fast managed deployment with little infrastructure work.
  • Always-on private capacity can become expensive.
Visit Replicate
PRODUCTION SERVING

Baseten

Best for engineering teams serving custom models with production observability and scaling.

  • Truss packaging, custom dependencies, GPU selection, and scale-to-zero.
  • Strong fit for custom PyTorch, Transformers, and inference stacks.
  • More technical than demo-first or catalog-first platforms.
Visit Baseten
GPU INFRASTRUCTURE

RunPod

Best for teams that need lower-cost GPU pods, serverless GPU, Docker, notebooks, or custom training.

  • Broad GPU selection, persistent volumes, SSH, Jupyter, and templates.
  • High control over runtime and deployment architecture.
  • You manage more of the API, security, dependency, and scaling work.
Visit RunPod
SERVERLESS PYTHON

Modal

Best for Python inference functions, APIs, batch processing, and scheduled ML jobs.

  • Serverless CPU/GPU functions, custom images, volumes, secrets, and autoscaling.
  • Efficient for intermittent workloads and Python-first pipelines.
  • Requires code and is not intended as a no-code demo builder.
Visit Modal
COMPUTER VISION

Roboflow

Best for end-to-end image datasets, annotation, augmentation, training, evaluation, and deployment.

  • Supports classification, segmentation, detection, hosted inference, and edge deployment.
  • Complete visual workflow with API and SDK integration.
  • Specialized for computer vision rather than general tabular ML.
Visit Roboflow

Platform comparison

PlatformPrimary useEntry pointOperational effort
AutoTrain MLNo-code tabular training and managed testingFree / $9.90 / $17.90 monthlyLow
Hugging Face SpacesInteractive Gradio or Streamlit demoFree basic CPULow
HF Inference EndpointsDedicated production model APICPU from roughly $23 monthlyLow to medium
ReplicateManaged model API and generative AIPer-second computeLow
BasetenCustom production inferenceUsage-based computeMedium
RunPodGPU pods and serverless GPUHourly or serverless usageHigh
ModalServerless Python APIs and jobsFree tier plus computeMedium
RoboflowEnd-to-end computer visionFree public plan / paid private plansLow to medium

Prices are indicative comparison points, not provider quotes. A continuously running GPU can range from a few hundred to several thousand US dollars per month depending on hardware, region, availability, and discounts.

Quick selection

  • Use AutoTrain ML for no-code tabular experiments, managed model testing, and stable prediction endpoints.
  • Use Hugging Face Spaces for an interactive demo with Gradio or Streamlit.
  • Use HF Inference Endpoints or Baseten for a managed production API.
  • Use Replicate for rapid generative-model API integration.
  • Use RunPod when GPU cost and runtime control matter more than operational simplicity.
  • Use Modal for serverless Python jobs and intermittent inference.
  • Use Roboflow for a complete computer-vision dataset and deployment workflow.

General export workflow

  1. Train and validate the model in AutoTrain ML.
  2. Export the model artifact and record its exact preprocessing configuration, feature schema, class labels, and runtime version.
  3. Package the model using the provider's supported repository, container, function, or SDK format.
  4. Configure CPU/GPU, scaling, secrets, storage, and access controls.
  5. Run representative validation inputs and compare outputs with AutoTrain Engine before routing production traffic.

Error responses

StatusMeaning
400Invalid file, colors, task, dimensions, or request body.
404The model job does not exist.
409The artifact is not ready or the endpoint does not match the model format.
413The uploaded model exceeds the configured upload limit.
422The model or prediction output cannot be decoded.
503The required model runtime is temporarily unavailable.

Limits and security

  • Free includes one dashboard testing tab and no inference API access.
  • Basic includes three testing tabs and three inference API endpoints; Advanced includes ten of each.
  • Testing has no per-test counter while an eligible plan is active. Protective fair-use and hourly rate limits may still apply.
  • When a paid subscription expires, projects above the Free limit are preserved but sealed and their inference API endpoints return an access error until renewal.
  • Uploaded BYOM artifacts remain stored until deleted by the account owner.
  • Images submitted for prediction are processed in memory and are not saved.
  • Keep job IDs private and apply your own server-side access policy when exposing an endpoint to end users.
  • Do not embed private credentials or unrestricted business logic in browser code.

Support: hello@autotrain.app