Jina AI

Jina AI — free-tier JSON endpoint

AUTH APIKEYCORS ✓AGENT ?HTTPS ✓COMMERCIAL ?

Jina AI offers a free API tier. We verified JSON on a sample GET (Machine Learning). Check provider docs for key requirements and limits.

—HOW IT'S SCORED ⓘ

▶ Run live Docs ↗

Status badge · for your README

ON PROBE SCHEDULE

We probe a documented GET and expect 2xx JSON — full uptime and health score. Open provider docs ↗

Uptime historystarts after first probe

On our probe schedule. Uptime charts appear after the first check lands.

Example responsefrom provider docs — not verified by us

GET https://api.jina.ai/openapi.json

{
  "openapi": "3.1.0",
  "info": {
    "title": "Jina Search Foundation API",
    "description": "\nBest-in-class embeddings, rerankers, and classifiers. Search AI for multilingual and multimodal data.\n\n## Capabilities\n\n- **Text Embeddings**: Dense vector representations for semantic search, similarity, and classification\n- **Multimodal Embeddings**: Process images, PDFs, and text in a unified vector space\n- **Reranking**: Refine search results with precise relevance scoring\n- **Classification**: Zero-shot and few-shot text classification\n- **Multi-vector Embeddings**: Token-level embeddings for ColBERT and late interaction\n- **Batch Embeddings**: Asynchronous bulk embedding processing via JSONL input/output\n\n## Authentication\n\nInclude your API key in the `Authorization` header:\n\n```\nAuthorization: Bearer jina_YOUR_API_KEY\n```\n\nGet your API key at [jina.ai/api-dashboard/key-manager](https://jina.ai/api-dashboard/key-manager). New users receive **10M free tokens**.\n\n## Rate Limits\n\n| Tier | RPM | TPM | Concurrency |\n|------|-----|-----|-------------|\n| Free | 500 | 1M | 5 |\n| Tier 1 | 500 | 10M | 50 |\n| Tier 2 | 5,000 | 100M | 500 |\n\nRate limit headers are included in responses: `X-RateLimit-Remaining-Requests`, `X-RateLimit-Remaining-Tokens`.\n\n## Error Codes\n\nAll endpoints may return the following errors. Endpoint-specific errors are documented per operation.\n\n| Code | Status | Description |\n|------|--------|-------------|\n| `INPUT_MODEL_NOT_FOUND` | 400 | Model 'X' not found |\n| `INPUT_INVALID_LABELS` | 400 | Invalid training labels |\n| `INPUT_LABEL_LIMIT_EXCEEDED` | 400 | Label limit exceeded: {current} labels provided, maximum N allowed for your plan |\n| `INPUT_TOKEN_LIMIT_EXCEEDED` | 400 | Input text exceeds the model's maximum of {max_tokens} tokens |\n| `AUTH_MISSING_API_KEY` | 401 | Authentication required |\n| `AUTH_INVALID_API_KEY` | 401 | Invalid API key |\n| `AUTH_INVALID_FORMAT` | 401 | Invalid authorization format |\n| `AUTHZ_INSUFFICIENT_BALANCE` | 403 | Insufficient account balance |\n| `AUTHZ_RESOURCE_LIMIT_EXCEEDED` | 403 | Resource limit exceeded for your plan |\n| `RESOURCE_NOT_FOUND` | 404 | {resource_type} '{resource_id}' not found or access denied |\n| `CONFLICT_RESOURCE_BUSY` | 409 | {resource_type} '{resource_id}' is currently being modified |\n| `RATE_REQUEST_LIMIT_EXCEEDED` | 429 | Request rate limit exceeded: {current}/N requests per minute |\n| `RATE_TOKEN_LIMIT_EXCEEDED` | 429 | Token rate limit exceeded: {current:,}/{limit:,} tokens per minute |\n| `RATE_CONCURRENCY_LIMIT_EXCEEDED` | 429 | Concurrency limit exceeded: {current}/N concurrent requests |\n| `RATE_IP_LIMIT_EXCEEDED` | 429 | IP rate limit exceeded |\n| `INTERNAL_ERROR` | 500 | An unexpected error occurred |\n| `SERVICE_UNAVAILABLE` | 503 | Service temporarily unavailable |\n| `SERVICE_TIMEOUT` | 504 | Service request timed out |\n",
    "version": "2026.06.29.1712",
    "x-logo": {
      "url": "https://jina.ai/Jina%20-%20Light.svg",
      "altText": "Jina AI",
      "href": "https://jina.ai"
    }
  },
  "paths": {
    "/health": {
      "get": {
        "tags": [
          "Health Check"
        ],
        "summary": "Health",
        "description": "Basic health check endpoint.\n\nReturns 200 if the service is running. This is the simplest health check\nthat only verifies the process is alive and can handle HTTP requests.",
        "operationId": "health_health_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          }
        }
      }
    },
    "/ready": {
      "get": {
        "tags": [
          "Health Check"
        ],
        "summary": "Ready",
        "description": "Readiness probe for Kubernetes/Cloud Run.\n\nChecks if the service is ready to accept traffic by verifying:\n- Redis connectivity (if redis_client is provided)\n\nReturns:\n    200 with status details if ready\n    503 with failure details if not ready",
        "operationId": "ready_ready_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          }
        }
      }
    },
    "/live": {
      "get": {
        "tags": [
          "Health Check"
        ],
        "summary": "Live",
        "description": "Liveness probe for Kubernetes/Cloud Run.\n\nLightweight check that the process is responsive. Unlike readiness,\nthis should not check external dependencies - it only verifies that\nthe event loop is not blocked and can handle requests.\n\nA failed liveness probe typically results in container restart.",
        "operationId": "live_live_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          }
        }
      }
    },
    "/v1/embeddings": {
      "post": {
        "tags": [
          "Search Foundation Models"
        ],
        "summary": "Embeddings",
        "description": "Generate embeddings for text, images, or documents.\n\nWorld-class multimodal multilingual embeddings for semantic search,\nsimilarity matching, clustering, and classification tasks.",
        "operationId": "embeddings_v1_embeddings_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "oneOf": [
                  {
                    "$ref": "#/components/schemas/EmbeddingsV2Request"
                  },
                  {
                    "$ref": "#/components/schemas/EmbeddingsV3Request"
                  }
                ],
                "title": "Embedding Request",
                "discriminator": {
                  "propertyName": "model",
                  "mapping": {
                    "jina-embeddings-v2-base-en": "#/components/schemas/EmbeddingsV2Request",
                    "jina-embeddings-v2-base-zh": "#/components/schemas/EmbeddingsV2Request",
                    "jina-embeddings-v2-base-de": "#/components/schemas/EmbeddingsV2Request",
                    "jina-embeddings-v2-base-es": "#/components/schemas/EmbeddingsV2Request",
                    "jina-embeddings-v2-base-code": "#/components/schemas/EmbeddingsV2Request",
                    "jina-embeddings-v3": "#/components/schemas/EmbeddingsV3Request",
                    "jina-embeddings-v5-text-nano": "#/components/schemas/EmbeddingsV5Request",
                    "jina-embeddings-v5-text-small": "#/components/schemas/EmbeddingsV5Request"
                  }
                }
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/EmbeddingResponse"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          }
        },
        "security": [
          {
            "HTTPBearer": []
          }
        ]
      }
    },
    "/v1/rerank": {
      "post": {
        "tags": [
          "Search Foundation Models"
        ],
        "summary": "Rerank",
        "description": "Rerank documents by relevance to a query.\n\nWorld-class reranker for maximizing search relevancy and RAG accuracy.",
        "operationId": "rerank_v1_rerank_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "oneOf": [
                  {
                    "$ref": "#/components/schemas/TextRerankerRequest"
                  },
                  {
                    "$ref": "#/components/schemas/RerankerM0Request"
                  }
                ],
                "title": "Reranking Request",
                "discriminator": {
                  "propertyName": "model",
                  "mapping": {
                    "jina-reranker-v2-base-multilingual": "#/components/schemas/TextRerankerRequest",
                    "jina-reranker-v1-tiny-en": "#/components/schemas/TextRerankerRequest",
                    "jina-reranker-v1-turbo-en": "#/components/schemas/TextRerankerRequest",
                    "jina-reranker-v1-base-en": "#/components/schemas/TextRerankerRequest",
                    "jina-colbert-v1-en": "#/components/schemas/TextRerankerRequest",
                    "jina-colbert-v2": "#/components/schemas/TextRerankerRequest",
                    "jina-reranker-m0": "#/components/schemas/RerankerM0Request",
                    "jina-reranker-v3": "#/components/schemas/RerankerV3Request"
                  }
                }
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/RerankingResponse"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          }
        },
        "security": [
          {
            "HTTPBearer": []
          }
        ]
      }
    },
    "/v1/classify": {
      "post": {
        "tags": [
          "Zero/Few-shot Classification"
        ],
        "summary": "Classify",
        "description": "Classify text or images into categories.\n\nZero-shot and few-shot classification. Zero-shot uses embedding similarity,\nfew-shot uses a trained classifier.",
        "operationId": "classify_v1_classify_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "anyOf": [
                  {
                    "oneOf": [
                      {
                        "$ref": "#/components/schemas/EmbeddingsV2ZeroShotClassificationRequest"
                      },
                      {
                        "$ref": "#/components/schemas/EmbeddingsV3ZeroShotClassificationRequest"
                      }
                    ],
                    "discriminator": {
                      "propertyName": "model",
                      "mapping": {
                        "jina-embeddings-v2-base-en": "#/components/schemas/EmbeddingsV2ZeroShotClassificationRequest",
                        "jina-embeddings-v2-base-zh": "#/components/schemas/EmbeddingsV2ZeroShotClassificationRequest",
                        "jina-embeddings-v2-base-de": "#/components/schemas/EmbeddingsV2ZeroShotClassificationRequest",
                        "jina-embeddings-v2-base-es": "#/components/schemas/EmbeddingsV2ZeroShotClassificationRequest",
                        "jina-embeddings-v2-base-code": "#/components/schemas/EmbeddingsV2ZeroShotClassificationRequest",
                        "jina-embeddings-v3": "#/components/schemas/EmbeddingsV3ZeroShotClassificationRequest",
                        "jina-embeddings-v4": "#/components/schemas/EmbeddingsV4ZeroShotClassificationRequest",
                        "jina-embeddings-v5-text-nano": "#/components/schemas/EmbeddingsV5ZeroShotClassificationRequest"
                      }
                    }
                  },
                  {
                    "$ref": "#/components/schemas/FewShotClassificationRequest"
                  }
                ],
                "title": "Classification Request"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ClassificationResponse"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          }
        },
        "security": [
          {
            "HTTPBearer": []
          }
        ]
      }
    },
    "/v1/train": {
      "post": {
        "tags": [
          "Zero/Few-shot Classification"
        ],
        "summary": "Train",
        "description": "Train or update a few-shot classifier.\n\nCreate a new classifier with labeled examples, or update an existing one\nwith additional training data.",
        "operationId": "train_v1_train_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "anyOf": [
                  {
                    "oneOf": [
                      {
                        "$ref": "#/components/schemas/EmbeddingsV2CreateTrainingRequest"
                      },
                      {
                        "$ref": "#/components/schemas/EmbeddingsV3CreateTrainingRequest"
                      }
                    ],
                    "discriminator": {
                      "propertyName": "model",
                      "mapping": {
                        "jina-embeddings-v2-base-en": "#/components/schemas/EmbeddingsV2CreateTrainingRequest",
                        "jina-embeddings-v2-base-zh": "#/components/schemas/EmbeddingsV2CreateTrainingRequest",
                        "jina-embeddings-v2-base-de": "#/components/schemas/EmbeddingsV2CreateTrainingRequest",
                        "jina-embeddings-v2-base-es": "#/components/schemas/EmbeddingsV2CreateTrainingRequest",
                        "jina-embeddings-v2-base-code": "#/components/schemas/EmbeddingsV2CreateTrainingRequest",
                        "jina-embeddings-v3": "#/components/schemas/EmbeddingsV3CreateTrainingRequest",
                        "jina-embeddings-v4": "#/components/schemas/EmbeddingsV4CreateTrainingRequest",
                        "jina-embeddings-v5-text-nano": "#/components/schemas/EmbeddingsV5CreateTrainingRequest"
                      }
                    }
                  },
                  {
                    "$ref": "#/components/schemas/UpdateTrainingRequest"
                  }
                ],
                "title": "Training Request"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/TrainingResponse"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          }
        },
        "security": [
          {
            "HTTPBearer": []
          }
        ]
      }
    },
    "/v1/classifiers": {
      "get": {
        "tags": [
          "Zero/Few-shot Classification"
        ],
        "summary": "List Classifiers",
        "description": "List all classifiers owned by the authenticated user.",
        "operationId": "list_classifiers_v1_classifiers_post",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/ClassifierSummary"
                  },
                  "type": "array",
                  "title": "Response List Classifiers V1 Classifiers Post"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          }
        },
        "security": [
          {
            "HTTPBearer": []
          }
        ]
      },
      "post": {
        "tags": [
          "Zero/Few-shot Classification"
        ],
        "summary": "List Classifiers",
        "description": "List all classifiers owned by the authenticated user.",
        "operationId": "list_classifiers_v1_classifiers_post",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/ClassifierSummary"
                  },
                  "type": "array",
                  "title": "Response List Classifiers V1 Classifiers Post"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "409": {
            "$ref": "#/components/responses/Conflict"
          },
          "429": {
            "$ref": "#/components/responses/TooManyRequests"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          }
        },
        "security": [
          {
            "HTTPBearer": []
          }
        ]
      }
    }
  },
  "components": {
    "schemas": {
      "AudioDoc": {
        "properties": {
          "audio": {
            "type": "string",
            "title": "Audio",
            "description": "Audio as a URL or base64-encoded string."
          }
        },
        "type": "object",
        "required": [
          "audio"
        ],
        "title": "AudioDoc"
      },
      "BaseUsage": {
        "properties": {
          "total_tokens": {
            "type": "integer",
            "title": "Total Tokens",
            "description": "Total number of tokens processed."
          }
        },
        "type": "object",
        "required": [
          "total_tokens"
        ],
        "title": "BaseUsage"
      },
      "BatchEmbeddingRequest": {
        "properties": {
          "model": {
            "type": "string",
            "enum": [
              "jina-embeddings-v5-text-nano",
              "jina-embeddings-v5-text-small"
            ],
            "title": "Model",
            "description": "The embedding model to use for batch processing."
          },
          "input_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Input Url",
            "description": "URL to input JSONL file (GCS, S3, or HTTP). Either input_url or input must be provided."
          },
          "input": {
            "anyOf": [
              {
                "items": {
                  "additionalProperties": true,
                  "type": "object"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Input",
            "description": "Inline JSONL lines for small batches. Either input_url or input must be provided."
          },
          "task": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Task",
            "description": "Task optimization: retrieval, text-matching, clustering, or classification.",
            "default": "text-matching"
          },
          "dimensions": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 1024,
                "exclusiveMinimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Dimensions",
            "description": "Number of dimensions for output embeddings (1-1024)."
          },
          "normalized": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Normalized",
            "description": "If true (default), embeddings are L2-normalized to unit length.",
            "default": true
          },
          "webhook_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Webhook Url",
            "description": "URL to POST notification when job completes."
          }
        },
        "type": "object",
        "required": [
          "model"
        ],
        "title": "BatchEmbeddingRequest",
        "description": "Request to create a batch embedding job.",
        "examples": [
          {
            "dimensions": 512,
            "input_url": "gs://my-bucket/inputs.jsonl",
            "model": "jina-embeddings-v5-text-small",
            "task": "retrieval"
          },
          {
            "input": [
              {
                "body": {
                  "input": "Hello world"
                },
                "custom_id": "req-1"
              },
              {
                "body": {
                  "input": "Batch embeddings"
                },
                "custom_id": "req-2"
              }
            ],
            "model": "jina-embeddings-v5-text-nano",
            "task": "text-matching"
          }
        ]
      },
      "BatchStats": {
        "properties": {
          "total": {
            "type": "integer",
            "title": "Total",
            "description": "Total number of input lines."
          },
          "completed": {
            "type": "integer",
            "title": "Completed",
            "description": "Number of successfully processed lines.",
            "default": 0
          },
          "failed": {
            "type": "integer",
            "title": "Failed",
            "description": "Number of failed lines.",
            "default": 0
          },
          "total_tokens": {
            "type": "integer",
            "title": "Total Tokens",
            "description": "Total tokens consumed across all processed lines.",
            "default": 0
          }
        },
        "type": "object",
        "required": [
          "total"
        ],
        "title": "BatchStats",
        "description": "Statistics for a batch job."
      },
      "BatchStatus": {
        "properties": {
          "batch_id": {
            "type": "string",
            "title": "Batch Id",
            "description": "Unique identifier for the batch job."
          },
          "status": {
            "type": "string",
            "enum": [
              "pending",
              "processing"
            ],
            "title": "Status",
            "description": "Current status of the batch job."
          },
          "model": {
            "type": "string",
            "title": "Model",
            "description": "The model used for embedding."
          },
          "created_at": {
            "type": "string",
            "title": "Created At",
            "description": "ISO 8601 timestamp when job was created."
          },
          "completed_at": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Completed At",
            "description": "ISO 8601 timestamp when job completed (if finished)."
          },
          "expires_at": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Expires At",
            "description": "ISO 8601 timestamp when output URL expires (created_at + 24h)."
          },
          "output_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Output Url",
            "description": "Signed URL to download output JSONL (24h expiry)."
          },
          "error_file_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Error File Url",
            "description": "URL to download error JSONL for failed lines."
          }
        },
        "type": "object",
        "required": [
          "batch_id",
          "status"
        ],
        "title": "BatchStatus",
        "description": "Status of a batch embedding job.",
        "examples": [
          {
            "batch_id": "batch_abc123",
            "completed_at": "2024-01-15T10:35:00Z",
            "created_at": "2024-01-15T10:30:00Z",
            "expires_at": "2024-01-16T10:30:00Z",
            "model": "jina-embeddings-v5-text-small",
            "output_url": "https://storage.googleapis.com/...",
            "stats": {
              "completed": 998,
              "failed": 2,
              "total": 1000
            },
            "status": "completed"
          }
        ]
      },
      "ClassificationPrediction": {
        "properties": {
          "object": {
            "type": "string",
            "title": "Object",
            "description": "Object type, always `classification`.",
            "default": "classification"
          },
          "index": {
            "type": "integer",
            "title": "Index",
            "description": "Position of this result in the input list."
          },
          "prediction": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "additionalProperties": {
                  "type": "string"
                },
                "type": "object"
              }
            ],
            "title": "Prediction",
            "description": "Predicted label, or a dict of labels per group."
          },
          "score": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "additionalProperties": {
                  "type": "number"
                },
                "type": "object"
              }
            ],
            "title": "Score",
            "description": "Confidence score, or a dict of scores per group."
          },
          "predictions": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/ClassificationPredictionLabel"
                },
                "type": "array"
              },
              {
                "additionalProperties": {
                  "items": {
                    "$ref": "#/components/schemas/ClassificationPredictionLabel"
                  },
                  "type": "array"
                },
                "type": "object"
              }
            ],
            "title": "Predictions",
            "description": "All candidate labels with scores, or a dict per group."
          }
        },
        "type": "object",
        "required": [
          "index",
          "prediction"
        ],
        "title": "ClassificationPrediction",
        "description": "Classification result for one input item."
      },
      "ClassificationPredictionLabel": {
        "properties": {
          "label": {
            "type": "string",
            "title": "Label",
            "description": "The candidate label."
          },
          "score": {
            "type": "number",
            "title": "Score",
            "description": "Confidence score for this label."
          }
        },
        "type": "object",
        "required": [
          "label",
          "score"
        ],
        "title": "ClassificationPredictionLabel",
        "description": "A label with its confidence score."
      },
      "ClassificationResponse": {
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/ClassificationPrediction"
            },
            "type": "array",
            "title": "Data",
            "description": "Classification results, one per input item."
          },
          "usage": {
            "$ref": "#/components/schemas/BaseUsage",
            "description": "Token usage statistics."
          }
        },
        "type": "object",
        "required": [
          "data",
          "usage"
        ],
        "title": "ClassificationResponse",
        "description": "Response containing classification results."
      }
    },
    "securitySchemes": {
      "HTTPBearer": {
        "type": "http",
        "scheme": "bearer"
      }
    },
    "responses": {
      "BadRequest": {
        "description": "- **INPUT_MODEL_NOT_FOUND**: Model 'model_name' not found. Available models: ....\n- **INPUT_INVALID_LABELS**: Invalid training labels. At least {min_labels} unique labels are required for training.\n- **INPUT_LABEL_LIMIT_EXCEEDED**: Label limit exceeded: {current} labels provided, maximum N allowed for your plan. Reduce the number of labels or upgrade your plan at https://jina.ai/api-dashboard/key-manager.\n- **INPUT_TOKEN_LIMIT_EXCEEDED**: Input text exceeds the model's maximum of {max_tokens} tokens. Use 'truncate: true' to automatically truncate, or split into smaller chunks.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        }
      },
      "Unauthorized": {
        "description": "- **AUTH_MISSING_API_KEY**: Authentication required. Provide your API key via the Authorization header: 'Authorization: Bearer <api-key>'. Get your API key at https://jina.ai/api-dashboard/key-manager.\n- **AUTH_INVALID_API_KEY**: Invalid API key. Verify your API key at https://jina.ai/api-dashboard/key-manager or generate a new one.\n- **AUTH_INVALID_FORMAT**: Invalid authorization format. Use 'Authorization: Bearer <api-key>' with a valid Jina API key (65 characters, starts with 'jina_').",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        }
      },
      "Forbidden": {
        "description": "- **AUTHZ_INSUFFICIENT_BALANCE**: Insufficient account balance. Top up your account at https://jina.ai/api-dashboard/key-manager.\n- **AUTHZ_RESOURCE_LIMIT_EXCEEDED**: Resource limit exceeded for your plan. Current: {current}, limit: N. Delete existing resources or upgrade your plan at https://jina.ai/api-dashboard/key-manager.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        }
      },
      "NotFound": {
        "description": "- **RESOURCE_NOT_FOUND**: {resource_type} '{resource_id}' not found or access denied. Verify the ID and your permissions.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        }
      },
      "Conflict": {
        "description": "- **CONFLICT_RESOURCE_BUSY**: {resource_type} '{resource_id}' is currently being modified. Please retry after a few moments.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        }
      },
      "TooManyRequests": {
        "description": "- **RATE_REQUEST_LIMIT_EXCEEDED**: Request rate limit exceeded: {current}/N requests per minute. Reduce request frequency or upgrade your plan at https://jina.ai/api-dashboard/key-manager.\n- **RATE_TOKEN_LIMIT_EXCEEDED**: Token rate limit exceeded: {current:,}/{limit:,} tokens per minute. Reduce batch sizes or upgrade your plan at https://jina.ai/api-dashboard/key-manager.\n- **RATE_CONCURRENCY_LIMIT_EXCEEDED**: Concurrency limit exceeded: {current}/N concurrent requests. Wait for pending requests to complete before sending new ones.\n- **RATE_IP_LIMIT_EXCEEDED**: IP rate limit exceeded. Too many requests from this IP address. Reduce request frequency.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        }
      },
      "InternalServerError": {
        "description": "- **INTERNAL_ERROR**: An unexpected error occurred. If this persists, contact support with the request_id from this response.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        }
      },
      "ServiceUnavailable": {
        "description": "- **SERVICE_UNAVAILABLE**: Service temporarily unavailable. Please retry with exponential backoff.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponse"
            }
          }
        }
      }
    }
  },
  "tags": [
    {
      "name": "Model List",
      "description": "List available Jina AI models and their capabilities.\n\nReturns model metadata in OpenRouter-compatible format including model IDs, input/output modalities, context lengths, and pricing information. Use this endpoint to discover available models before making API calls.\n"
    },
    {
      "name": "Search Foundation Models",
      "description": "Generate embeddings and rerank documents using state-of-the-art models.\n\n**Embeddings** convert text, images, and documents into dense vector representations for semantic search, RAG, and similarity matching. Available models include `jina-embeddings-v3` (multilingual, 8K context), `jina-embeddings-v4` (multimodal, 32K context), `jina-embeddings-v5-text-small` (multilingual, 32K context, 1024-dim), `jina-embeddings-v5-text-nano` (multilingual, 8K context, 768-dim), `jina-embeddings-v5-omni-small` (multilingual multimodal, 32K context, 1024-dim), `jina-embeddings-v5-omni-nano` (multilingual multimodal, 8K context, 768-dim), and `jina-clip-v2` (text-image, 89 languages).\n\n**Reranking** refines search results by scoring query-document relevance. Models include `jina-reranker-v3` (0.6B, 131K context, listwise reranking), `jina-reranker-m0` (multimodal, 29 languages), `jina-reranker-v2-base-multilingual` (100+ languages, function calling support), and `jina-colbert-v2` (late interaction for high precision).\n"
    }
  ]
}

Call itcurl · fetch · python

curl "https://api.jina.ai/openapi.json"

const res = await fetch("https://api.jina.ai/openapi.json");
const data = await res.json();
console.log(data);

import requests

res = requests.get("https://api.jina.ai/openapi.json")
print(res.json())

Endpoints · 3On scheduleFULL DOCS ↗

On schedule — GET /openapi.json awaits first probe

GET/openapi.jsonPROBED

Jina AI — free-tier JSON endpoint

GET/openapi.json?limit=5

Paginated variant with limit parameter.

GET/scalar

Scalar — documented GET route.

Machine-readable spec

We probe a documented GET and expect 2xx JSON — full uptime and health score. Export includes every documented route below.

Response-shape history

Not tracked yet. Shape-change history starts once this API joins our probe schedule.

Jina AI: common questions

Is Jina AI free to use?

Yes — Jina AI is a free science & space API. Free tier: Free tier — API key may be required for production. Whether the free tier allows commercial use is unclear — check the provider docs.

Does Jina AI need an API key?

Yes — Jina AI needs a free API key, which you pass on each request. Rate limits: Unpublished.

Can I call Jina AI from the browser?

Yes — Jina AI returns CORS headers over HTTPS, so front-end code can fetch it directly with no backend proxy. Use the fetch snippet on this page, or hit "Run live" to try it now.

Is Jina AI up right now?

Jina AI is catalogued but not yet on our probe schedule, so we don't publish a live status for it. Check the provider's own status page or docs for its current state.

Metadatasome fields awaiting probe

Authfrom docsapiKey

CORSlive probeyes

Commercial usependingunclear

HTTPSfrom docsyes

Free tierfrom docsFree tier — API key may be required for production

Rate limitpendingUnpublished

Card requiredfrom docsno

Data licensefrom docsUnverified

Base URL

In directory since2026-07-05

Agent contextpaste into chat

// jina-ai · UNMONITORED · health — · auth apiKey · cors yes
{
  "base_url": "https://api.jina.ai",
  "sample": "https://api.jina.ai/openapi.json",
  "auth": "apiKey",
  "status": "unmonitored",
  "commercial_use": "unclear",
  "docs": "https://jina.ai",
  "record": "https://shipapis.dev/api/v1/apis/jina-ai"
}

Everything an agent needs to call Jina AI — from our last verified record.

Similar · health-ranked

NASA APOD—VS

Open Notify—VS

Not Human Search—VS

TensorFeed—VS

This page, as JSON

$ curl 'https://shipapis.dev/api/v1/apis/jina-ai'

Health, uptime & verified metadata — free, no auth. Meta-API docs