# AI Text Humanizer API — Make AI Writing Sound Human (`george.the.developer/ai-text-humanizer-api`) Actor

Transform AI text into natural human writing. 12-pass engine: phrase replacement, contractions, sentence variation, imperfections. Before/after AI detection scores. 5 styles, 3 levels. Sub-500ms.

- **URL**: https://apify.com/george.the.developer/ai-text-humanizer-api.md
- **Developed by:** [George Kioko](https://apify.com/george.the.developer) (community)
- **Categories:** Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 57 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 text humanizeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Text Humanizer API

#### Make AI Writing Sound Human. Instantly.

[![Pricing](https://img.shields.io/badge/price-$0.003%2Ftext-brightgreen?style=for-the-badge)](https://apify.com/george.the.developer/ai-text-humanizer-api)
[![Speed](https://img.shields.io/badge/speed-%3C500ms-blue?style=for-the-badge)](https://apify.com/george.the.developer/ai-text-humanizer-api)
[![Styles](https://img.shields.io/badge/styles-5%20writing%20modes-purple?style=for-the-badge)](https://apify.com/george.the.developer/ai-text-humanizer-api)
[![Detection](https://img.shields.io/badge/detection-9--factor%20scoring-orange?style=for-the-badge)](https://apify.com/george.the.developer/ai-text-humanizer-api)
[![Passes](https://img.shields.io/badge/engine-12%20transform%20passes-red?style=for-the-badge)](https://apify.com/george.the.developer/ai-text-humanizer-api)
[![Bulk](https://img.shields.io/badge/bulk-20%20texts%2Frequest-teal?style=for-the-badge)](https://apify.com/george.the.developer/ai-text-humanizer-api)

***

**Paste in ChatGPT output. Get back text that reads like a human wrote it.** Every response includes AI detection scores *before* and *after* so you can see the difference yourself.

12-pass algorithmic engine. Zero external API calls. No GPT wrapper. No rate limits from OpenAI. Just fast, deterministic humanization at **$0.003 per text**.

> *"I ran my blog post through this and GPTZero went from 94% AI to 22% likely human. Three-tenths of a cent."* -- early tester

***

### Before & After

| | AI-Generated Input | Humanized Output |
|---|---|---|
| **Text** | Furthermore, it is important to note that artificial intelligence has significantly impacted the landscape of modern technology. Additionally, this paradigm shift serves as a testament to the rapidly evolving nature of cutting-edge innovation. In conclusion, leveraging these robust solutions provides a comprehensive overview of the competitive advantage organizations can obtain. | Look, AI has made a real difference in modern tech. What's more, this big change shows what's possible with fast-changing innovation. Basically, using these solid solutions gives you a full breakdown of the edge organizations can get. |
| **AI Score** | **87/100** -- `ai_generated` | **31/100** -- `likely_human` |
| **Verdict** | Robotic. Formulaic. Obviously AI. | Natural. Varied. Reads like a person. |

**56-point drop in AI detection.** Same meaning. One API call.

***

### How It Works

```mermaid
flowchart LR
    A["AI Text Input"] --> B["Detect AI Score\n(9-factor analysis)"]
    B --> C["12 Humanization\nPasses"]
    C --> D["Re-Score Output\n(verify improvement)"]
    D --> E["Return Result\n+ before/after scores"]

    style A fill:#ff6b6b,color:#fff
    style B fill:#ffa94d,color:#fff
    style C fill:#51cf66,color:#fff
    style D fill:#339af0,color:#fff
    style E fill:#845ef7,color:#fff
```

#### The 12-Pass Humanization Engine

```mermaid
flowchart TB
    subgraph "Phase 1: Pattern Removal"
        P1["Pass 1: AI Phrase Replacement\n40+ phrases → natural alternatives"]
        P2["Pass 2: Contraction Injection\nit is → it's, do not → don't"]
        P3["Pass 3: Style Vocabulary\nAdjust tone for chosen style"]
    end

    subgraph "Phase 2: Rhythm & Structure"
        P4["Pass 4: Sentence Length Variation\nBreak long sentences, merge short ones"]
        P5["Pass 5: Starter Diversification\nVary how sentences begin"]
        P6["Pass 6: Comma Density Reduction\nRemove AI's excessive comma patterns"]
    end

    subgraph "Phase 3: Human Touch"
        P7["Pass 7: Imperfection Injection\nParentheticals, dashes, asides"]
        P8["Pass 8: Formal → Casual Words\nutilize → use, obtain → get"]
        P9["Pass 9: Burstiness Introduction\nVary sentence complexity"]
    end

    subgraph "Phase 4: Polish"
        P10["Pass 10: Structure Pattern Breaking\nStop repetitive X is Y patterns"]
        P11["Pass 11: Readability Adjustment\nTarget natural grade level"]
        P12["Pass 12: Final Cleanup\nRemove artifacts, smooth flow"]
    end

    P1 --> P2 --> P3 --> P4 --> P5 --> P6 --> P7 --> P8 --> P9 --> P10 --> P11 --> P12

    style P1 fill:#ff6b6b,color:#fff
    style P2 fill:#ff8787,color:#fff
    style P3 fill:#ffa8a8,color:#fff
    style P4 fill:#ffa94d,color:#fff
    style P5 fill:#ffc078,color:#fff
    style P6 fill:#ffd8a8,color:#fff
    style P7 fill:#51cf66,color:#fff
    style P8 fill:#69db7c,color:#fff
    style P9 fill:#8ce99a,color:#fff
    style P10 fill:#339af0,color:#fff
    style P11 fill:#4dabf7,color:#fff
    style P12 fill:#74c0fc,color:#fff
```

***

### Quick Start

#### cURL -- Humanize in One Line

```bash
curl "https://george-the-developer--ai-text-humanizer-api.apify.actor/humanize?text=Furthermore%2C%20it%20is%20important%20to%20note%20that%20artificial%20intelligence%20has%20significantly%20impacted%20the%20landscape%20of%20modern%20technology."
```

#### JavaScript / Node.js

```javascript
// Humanize a single text
const response = await fetch(
  'https://george-the-developer--ai-text-humanizer-api.apify.actor/humanize',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer YOUR_APIFY_TOKEN'
    },
    body: JSON.stringify({
      text: 'Furthermore, it is important to note that artificial intelligence has significantly impacted the landscape of modern technology.',
      style: 'casual',        // casual | professional | academic | creative | technical
      aggressiveness: 'medium' // light | medium | heavy
    })
  }
);

const result = await response.json();
console.log(result.humanized);
// "Also, AI has made a real difference in modern tech."

console.log(result.detection);
// { before: { score: 87, verdict: 'ai_generated' },
//   after:  { score: 31, verdict: 'likely_human' },
//   improvement: 56 }
```

#### Python

```python
import requests

result = requests.post(
    'https://george-the-developer--ai-text-humanizer-api.apify.actor/humanize',
    headers={'Authorization': 'Bearer YOUR_APIFY_TOKEN'},
    json={
        'text': 'Furthermore, it is important to note that artificial intelligence has significantly impacted the landscape of modern technology.',
        'style': 'professional',
        'aggressiveness': 'heavy'
    }
).json()

print(f"Before: {result['detection']['before']['score']}/100 ({result['detection']['before']['verdict']})")
print(f"After:  {result['detection']['after']['score']}/100 ({result['detection']['after']['verdict']})")
print(f"Humanized: {result['humanized']}")
```

#### Bulk Processing (Up to 20 Texts)

```javascript
const response = await fetch(
  'https://george-the-developer--ai-text-humanizer-api.apify.actor/humanize/bulk',
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer YOUR_APIFY_TOKEN'
    },
    body: JSON.stringify({
      texts: [
        { text: 'First AI paragraph here...', style: 'casual' },
        { text: 'Second AI paragraph here...', style: 'professional' },
        { text: 'Third AI paragraph here...', style: 'academic' }
      ],
      aggressiveness: 'medium'
    })
  }
);

const { results, total } = await response.json();
// results[0].humanized, results[1].humanized, ...
```

#### AI Detection Only (No Humanization)

```bash
curl "https://george-the-developer--ai-text-humanizer-api.apify.actor/detect?text=Your+text+here"
```

***

### 5 Writing Styles

The same AI input transformed into five distinct voices:

> **AI Input:** "Furthermore, it is important to note that implementing robust cybersecurity measures is essential for organizations seeking to obtain a competitive advantage in the digital landscape."

| Style | Output | Best For |
|-------|--------|----------|
| **Casual** | "Look, good cybersecurity really matters if you want an edge in the digital world." | Blog posts, social media, emails |
| **Professional** | "Strong cybersecurity measures are essential for organizations looking to maintain a competitive edge in the digital space." | Business writing, reports, LinkedIn |
| **Academic** | "Implementing substantive cybersecurity measures remains essential for organizations seeking a competitive advantage in the digital domain." | Papers, research, dissertations |
| **Creative** | "Solid cybersecurity isn't just nice to have -- it's genuinely the thing that gives companies their edge in today's digital world." | Marketing copy, articles, storytelling |
| **Technical** | "Implementing performant cybersecurity measures is essential for organizations requiring a competitive advantage in digital infrastructure." | Documentation, whitepapers, specs |

***

### 3 Aggressiveness Levels

| Level | What It Does | Best For |
|-------|-------------|----------|
| **Light** | Replaces AI phrases + adds contractions + applies style. Safe, meaning-preserving. | Professional docs where subtle changes are enough |
| **Medium** | Everything in Light + sentence restructuring + starter diversification + comma reduction + subtle imperfections. | General purpose. Start here. |
| **Heavy** | Everything in Medium + aggressive imperfection injection + maximum burstiness. Text sounds distinctly human. | When you need to pass strict AI detectors |

***

### Why This Humanizer?

| Feature | This API | Quillbot | Undetectable.ai | WriteHuman |
|---------|----------|----------|-----------------|------------|
| **Price** | **$0.003/text** | $9.95/mo | $9.99/mo | $12/mo |
| **API Access** | **Yes (instant)** | No API | Limited API | No API |
| **Speed** | **<500ms** | 2-5s | 3-8s | 2-6s |
| **Before/After Scores** | **Included free** | No | Separate tool | No |
| **Bulk Processing** | **20 texts/request** | 1 at a time | 1 at a time | 1 at a time |
| **Style Options** | **5 styles** | 1 mode | 2 modes | 1 mode |
| **Aggressiveness Control** | **3 levels** | None | None | None |
| **External API Dependency** | **None (pure algo)** | GPT-based | GPT-based | GPT-based |
| **Pay-per-use** | **Yes** | Monthly only | Monthly only | Monthly only |
| **Works Programmatically** | **REST API** | Browser only | Browser only | Browser only |

**The math:** Humanize 1,000 texts/month and you pay **$3.00**. Their monthly plan costs 3-4x that for the same volume -- and they don't even have an API.

***

### AI Detection Methodology

The built-in detector analyzes text across **9 weighted factors**:

| Factor | Weight | What It Measures |
|--------|--------|-----------------|
| **AI Phrase Density** | 22% | Frequency of 40+ known AI transition phrases |
| **Sentence Uniformity** | 15% | How consistent sentence lengths are (AI = very uniform) |
| **Burstiness** | 12% | Variation in sentence complexity (humans are bursty) |
| **Vocabulary Diversity** | 10% | Type-Token Ratio -- unique words vs total words |
| **Starter Diversity** | 10% | Whether sentences begin the same way repeatedly |
| **Paragraph Uniformity** | 8% | How equal paragraph lengths are |
| **Readability Band** | 8% | Whether text sits in the AI-typical grade 10-14 band |
| **Structure Repetition** | 8% | Repetitive "X is Y" and "X can Y" patterns |
| **Comma Pattern** | 7% | AI uses 1.5-3 commas per sentence consistently |

#### Score Interpretation

| Score Range | Verdict | Meaning |
|-------------|---------|---------|
| 80-100 | `ai_generated` | Almost certainly written by AI |
| 60-79 | `likely_ai` | Strong AI signals detected |
| 40-59 | `mixed` | Could be either -- some AI patterns present |
| 20-39 | `likely_human` | Mostly human characteristics |
| 0-19 | `human_written` | No significant AI patterns found |

***

### API Reference

#### `GET /humanize`

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `text` | string | *required* | The text to humanize (max 50,000 chars) |
| `style` | string | `casual` | `casual` | `professional` | `academic` | `creative` | `technical` |
| `level` | string | `medium` | `light` | `medium` | `heavy` |

#### `POST /humanize`

```json
{
  "text": "Your AI-generated text here...",
  "style": "casual",
  "aggressiveness": "medium",
  "preserveMeaning": true
}
```

#### `POST /humanize/bulk`

```json
{
  "texts": [
    { "text": "First text...", "style": "casual" },
    { "text": "Second text...", "style": "professional" }
  ],
  "aggressiveness": "medium"
}
```

#### `GET /detect`

| Parameter | Type | Description |
|-----------|------|-------------|
| `text` | string | The text to analyze for AI patterns |

#### Response Format (Humanize)

```json
{
  "original": "Furthermore, it is important to note that...",
  "humanized": "Look, it's important to know that...",
  "originalLength": 142,
  "humanizedLength": 98,
  "detection": {
    "before": { "score": 87, "verdict": "ai_generated" },
    "after": { "score": 31, "verdict": "likely_human" },
    "improvement": 56
  },
  "settings": {
    "style": "casual",
    "aggressiveness": "medium",
    "preserveMeaning": true
  },
  "aiPhrases": {
    "removed": 5,
    "remaining": 0
  }
}
```

#### Response Format (Detect)

```json
{
  "score": 87,
  "verdict": "ai_generated",
  "factors": [
    { "name": "ai_phrases", "score": 95, "weight": 22, "detail": "6 phrases found", "phrases": ["furthermore", "in conclusion"] },
    { "name": "sentence_uniformity", "score": 85, "weight": 15, "detail": "CV=0.18" },
    { "name": "burstiness", "score": 90, "weight": 12, "detail": null }
  ]
}
```

***

### AI Agent Integration

Building an AI agent or workflow that generates content? Pipe it through this API as the last step.

#### LangChain / AI Pipeline

```javascript
// After your LLM generates text, humanize it before publishing
async function humanizeOutput(aiText, style = 'professional') {
  const res = await fetch(
    'https://george-the-developer--ai-text-humanizer-api.apify.actor/humanize',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer YOUR_APIFY_TOKEN'
      },
      body: JSON.stringify({ text: aiText, style, aggressiveness: 'medium' })
    }
  );
  const data = await res.json();
  return data.humanized;
}

// In your pipeline:
const draft = await llm.generate('Write a blog post about...');
const published = await humanizeOutput(draft, 'casual');
// published reads like a human wrote it
```

#### Python Agent

```python
import requests

def humanize(text, style='casual', level='medium'):
    """Drop-in function for any Python AI pipeline."""
    r = requests.post(
        'https://george-the-developer--ai-text-humanizer-api.apify.actor/humanize',
        headers={'Authorization': 'Bearer YOUR_APIFY_TOKEN'},
        json={'text': text, 'style': style, 'aggressiveness': level}
    )
    return r.json()

## Use it anywhere
result = humanize(chatgpt_output, style='professional', level='heavy')
print(result['humanized'])
print(f"AI score dropped from {result['detection']['before']['score']} to {result['detection']['after']['score']}")
```

***

### Pricing

**$0.003 per text humanized.** Detection-only requests (`/detect`) are free.

| Volume | Cost | Per-Text |
|--------|------|----------|
| 100 texts | $0.30 | $0.003 |
| 1,000 texts | $3.00 | $0.003 |
| 10,000 texts | $30.00 | $0.003 |
| 100,000 texts | $300.00 | $0.003 |

No monthly fees. No minimums. No commitments. You pay only for what you humanize.

**Compare:** Undetectable.ai charges $9.99/month for ~5,000 words. That's roughly 50 paragraphs. With this API, 50 texts costs **$0.15**.

***

### Use Cases

| Who | Why | Style |
|-----|-----|-------|
| **Content Creators** | Make AI-drafted blog posts sound authentic | `casual` or `creative` |
| **SEO Professionals** | Google's helpful content update penalizes AI-sounding text | `professional` |
| **Students** | Polish AI-assisted research while keeping academic tone | `academic` |
| **Email Marketers** | Warm up cold emails so they don't read like a template | `casual` |
| **Social Media Managers** | AI-generated posts that sound like real people | `casual` + `heavy` |
| **Technical Writers** | Clean up AI-drafted docs without losing precision | `technical` |
| **Agencies** | Humanize client deliverables at scale with bulk endpoint | Any + `bulk` |
| **AI Agent Builders** | Last-mile processing before publishing LLM output | Any |

***

### Frequently Asked Questions

#### Does it beat GPTZero, Originality.ai, and other detectors?

The humanizer targets the same patterns these detectors look for: sentence uniformity, AI transition phrases, burstiness, vocabulary diversity, and structural repetition. In testing, AI scores typically drop 40-60 points. Results vary by input length and original AI density. The built-in before/after scoring lets you verify every single result.

#### How does it work without using GPT or any LLM?

Pure algorithmic transforms. The engine doesn't "rewrite" your text with another AI -- it applies 12 deterministic passes that systematically remove AI patterns. This means: no hallucinations, no meaning drift, no external API costs, and sub-500ms response times. Your text goes in, the same text comes out with AI fingerprints removed.

#### Is it ethical to use?

This tool helps you sound like yourself. If you use AI to draft content (like most professionals now do), humanizing the output is no different than editing a first draft. The tool preserves your meaning while removing robotic patterns. We include detection scores for full transparency -- you always know exactly what changed.

#### What's the maximum text length?

50,000 characters per text. For bulk requests, up to 20 texts per call. No rate limits on the API itself.

#### Does it work for non-English text?

The current version is optimized for English. The phrase replacement dictionaries, contraction rules, and readability formulas are English-specific. Other languages may see partial improvement from structural transforms.

#### Why is detection included for free?

Detection lets you verify the humanization worked. It also makes the API useful for the opposite use case -- checking if content you received was AI-generated. Both directions, one API.

***

### Endpoints Summary

| Method | Path | Description | Cost |
|--------|------|-------------|------|
| `GET` | `/` | Health check + documentation | Free |
| `GET` | `/humanize?text=...` | Quick humanization | $0.003 |
| `POST` | `/humanize` | Humanize with full options | $0.003 |
| `POST` | `/humanize/bulk` | Bulk humanize up to 20 texts | $0.003/text |
| `GET` | `/detect?text=...` | AI detection scoring only | Free |
| `POST` | `/detect` | AI detection (POST body) | Free |

***

### Run on Apify

You can also run this actor directly on Apify with input:

```json
{
  "text": "Your AI-generated text to humanize...",
  "style": "casual",
  "aggressiveness": "medium"
}
```

The actor works in two modes:

1. **Standby API** (default) -- instant HTTP responses at the endpoints above
2. **Standard run** -- pass input directly, results saved to dataset

***

Built by [george.the.developer](https://apify.com/george.the.developer) on Apify.

# Actor input Schema

## `text` (type: `string`):

The AI-generated text you want to make sound more human.

## `style` (type: `string`):

Target writing style for humanization.

## `aggressiveness` (type: `string`):

How aggressively to rewrite. 'light' preserves more original structure, 'heavy' makes bigger changes.

## `preserveMeaning` (type: `boolean`):

Ensure the humanized text maintains the same core meaning.

## Actor input object example

```json
{
  "text": "Furthermore, it is worth noting that artificial intelligence has revolutionized the way we approach data analysis. In today's rapidly evolving landscape, organizations must adapt to leverage these powerful tools effectively. Consequently, businesses that embrace AI-driven solutions will find themselves at a significant competitive advantage.",
  "style": "casual",
  "aggressiveness": "medium",
  "preserveMeaning": true
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "text": "Furthermore, it is worth noting that artificial intelligence has revolutionized the way we approach data analysis. In today's rapidly evolving landscape, organizations must adapt to leverage these powerful tools effectively. Consequently, businesses that embrace AI-driven solutions will find themselves at a significant competitive advantage."
};

// Run the Actor and wait for it to finish
const run = await client.actor("george.the.developer/ai-text-humanizer-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "text": "Furthermore, it is worth noting that artificial intelligence has revolutionized the way we approach data analysis. In today's rapidly evolving landscape, organizations must adapt to leverage these powerful tools effectively. Consequently, businesses that embrace AI-driven solutions will find themselves at a significant competitive advantage." }

# Run the Actor and wait for it to finish
run = client.actor("george.the.developer/ai-text-humanizer-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "text": "Furthermore, it is worth noting that artificial intelligence has revolutionized the way we approach data analysis. In today'\''s rapidly evolving landscape, organizations must adapt to leverage these powerful tools effectively. Consequently, businesses that embrace AI-driven solutions will find themselves at a significant competitive advantage."
}' |
apify call george.the.developer/ai-text-humanizer-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,george.the.developer/ai-text-humanizer-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/JboiGyDhE1RdFUFlb/builds/HigMO0eEA4GgQFymH/openapi.json