# WordPress Integration (`new-world-scripts/wordpress-integration`) Actor

Manage WordPress content from Apify. Pull WordPress posts and pages, upload draft or published posts from JSON input, and delete WordPress posts by ID using the WordPress REST API.

- **URL**: https://apify.com/new-world-scripts/wordpress-integration.md
- **Developed by:** [New World Scripts](https://apify.com/new-world-scripts) (community)
- **Categories:** Automation, Integrations, Developer tools
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $30.00 / 1,000 wordpress post uploads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## WordPress Integration

Manage WordPress content from Apify using the WordPress REST API. This Actor helps you pull WordPress posts, upload new WordPress posts, pull WordPress pages, and delete WordPress posts by ID.

It is built for WordPress content automation, content migration checks, editorial workflows, backup exports, and simple publishing operations from structured JSON input.

### What this Actor does

| Action | Description |
|---|---|
| `pull_posts` | Pull WordPress posts and save the run results |
| `upload_posts` | Upload/create WordPress posts from JSON input |
| `pull_pages` | Pull WordPress pages and save the run results |
| `delete_post` | Delete one WordPress post by ID |
| `test_auth` | Test whether WordPress accepts the username and Application Password |

### Common use cases

- Export WordPress posts for review, backup, migration, enrichment, or analysis.
- Export WordPress pages from a site through the REST API.
- Upload draft WordPress posts from structured JSON.
- Publish content to WordPress from automation workflows.
- Create WordPress posts from prepared titles, HTML content, and optional meta fields.
- Delete a WordPress post by ID from an Apify run.

### Input

The Actor input is configured in the Apify Console. The `action` field is a dropdown.

| Field | Type | Required | Description |
|---|---:|---:|---|
| `siteUrl` | string | Yes | Full WordPress site URL, for example `https://example.com` |
| `username` | string | Yes | WordPress username |
| `appPassword` | string | Yes | WordPress Application Password |
| `action` | string | Yes | One of `pull_posts`, `upload_posts`, `pull_pages`, `delete_post`, `test_auth` |
| `postType` | string | No | Where to upload content. Use `post` for normal blog posts, `page` for website pages, or a custom WordPress content type if your site has one |
| `postStatus` | string | No | Status for uploaded posts: `draft`, `publish`, `pending`, or `private` |
| `maxPosts` | integer | No | Maximum posts/pages to pull. Use `0` for unlimited |
| `deletePostId` | integer | For `delete_post` | WordPress post ID to delete |
| `itemsToPush` | array | For `upload_posts` | Array of post objects with `title`, `content`, optional image URLs, and optional `meta` |

### Example inputs

#### Pull WordPress posts

```json
{
  "siteUrl": "https://yourwordpresssite.com",
  "username": "admin",
  "appPassword": "xxxx xxxx xxxx xxxx xxxx xxxx",
  "action": "pull_posts",
  "maxPosts": 100
}
````

#### Pull WordPress pages

```json
{
  "siteUrl": "https://yourwordpresssite.com",
  "username": "admin",
  "appPassword": "xxxx xxxx xxxx xxxx xxxx xxxx",
  "action": "pull_pages",
  "maxPosts": 50
}
```

#### Upload WordPress posts

```json
{
  "siteUrl": "https://yourwordpresssite.com",
  "username": "admin",
  "appPassword": "xxxx xxxx xxxx xxxx xxxx xxxx",
  "action": "upload_posts",
  "postStatus": "draft",
  "itemsToPush": [
    {
      "title": "New WordPress post from Apify",
      "content": "<p>This post was uploaded from Apify input.</p>\n{{image1}}\n<p>Text after the image.</p>",
      "featuredImageUrl": "https://picsum.photos/seed/wp-featured-image/1200/800.jpg",
      "imageUrls": [
        "https://picsum.photos/seed/wp-body-image/900/600.jpg"
      ],
      "imageOptions": [
        {
          "width": 900,
          "alt": "Example image uploaded from Apify"
        }
      ],
      "meta": {
        "source": "apify"
      }
    }
  ]
}
```

#### Delete a WordPress post

```json
{
  "siteUrl": "https://yourwordpresssite.com",
  "username": "admin",
  "appPassword": "xxxx xxxx xxxx xxxx xxxx xxxx",
  "action": "delete_post",
  "deletePostId": 123
}
```

### Output

Apify stores run results in the default run dataset so you can inspect, download, or connect them to another workflow.

Example result for a pulled WordPress post:

```json
{
  "id": 123,
  "title": "Example WordPress Post",
  "content": "<p>Post content...</p>",
  "excerpt": "<p>Short excerpt...</p>",
  "link": "https://yourwordpresssite.com/example-post/",
  "status": "publish",
  "date": "2026-05-26T10:30:00",
  "meta": {}
}
```

Example result for an uploaded post:

```json
{
  "id": 456,
  "title": "New WordPress post from Apify",
  "link": "https://yourwordpresssite.com/new-wordpress-post-from-apify/",
  "status": "draft",
  "action": "created",
  "timestamp": "2026-05-26T10:45:00"
}
```

### Image support

Uploaded posts can include images.

Use `featuredImageUrl` for the main WordPress featured image:

```json
{
  "title": "Post with featured image",
  "content": "<p>This post has a featured image.</p>",
  "featuredImageUrl": "https://example.com/main-image.jpg"
}
```

Use `imageUrls` for images that should be uploaded to WordPress and added inside the post body. To control placement, add placeholders in the content:

```json
{
  "title": "Post with body images",
  "content": "<p>Intro text.</p>\n{{image1}}\n<p>Middle text.</p>\n{{image2}}\n<p>Ending text.</p>",
  "imageUrls": [
    "https://example.com/image-1.jpg",
    "https://example.com/image-2.jpg"
  ]
}
```

`{{image1}}` is replaced by the first URL in `imageUrls`, `{{image2}}` is replaced by the second URL, and so on. If an image URL has no matching placeholder, it is added at the end of the post content.

Use `imageOptions` to control display size and alt text:

```json
{
  "title": "Post with sized image",
  "content": "<p>Intro text.</p>\n{{image1}}",
  "imageUrls": [
    "https://example.com/image-1.jpg"
  ],
  "imageOptions": [
    {
      "width": 700,
      "height": 400,
      "alt": "Product photo",
      "class": "aligncenter"
    }
  ]
}
```

If the WordPress post content already contains `<img>` tags, those tags stay in the content. Separate image URLs are uploaded to the WordPress Media Library.

### WordPress setup

This Actor uses WordPress Application Passwords with Basic Authentication.

1. Open your WordPress admin dashboard.
2. Go to **Users > Profile > Application Passwords**.
3. Add a new application password, for example `Apify`.
4. Copy the generated password. WordPress shows it only once.
5. Use your WordPress username and that Application Password in the Actor input.

Do not use your normal WordPress login password, hosting password, or sandbox access code.

### Notes and limitations

- The upload action creates new WordPress posts. It does not update existing posts.
- WordPress custom post types may require REST API support to be enabled in WordPress.
- WordPress meta fields must be registered and exposed to the REST API before WordPress will accept them.
- Image URLs must be publicly accessible so WordPress can download and upload them to the Media Library.
- Deleting posts uses `force=true`, which permanently deletes the post instead of moving it to trash.

### Monetization events

This Actor supports Apify Pay per event pricing. Configure these event names in the Apify Console if you publish the Actor as a paid Actor:

| Event name | Recommended starting price |
|---|---:|
| `wordpress-post-pulled` | `$0.002` |
| `wordpress-page-pulled` | `$0.002` |
| `wordpress-post-uploaded` | `$0.02` |
| `wordpress-post-deleted` | `$0.005` |

The Actor charges these events after a WordPress operation succeeds. Do not manually charge the synthetic `apify-actor-start` event in code.

### Troubleshooting

#### 401 Unauthorized

Check your WordPress username and Application Password. Use the Application Password generated in WordPress admin, not your regular login password.

#### REST API not available

Open this URL in your browser:

```text
https://yourwordpresssite.com/wp-json/wp/v2/posts
```

If it does not load, your WordPress REST API may be blocked by a security plugin, firewall, hosting rule, or permalink configuration.

#### Custom post type does not work

Confirm that the custom post type is exposed in the WordPress REST API. In WordPress code this usually requires `show_in_rest: true`.

### Local development

```bash
pip install -r requirements.txt
copy .env.example .env
python src/main.py
```

For local runs, configure values in `.env` or create an `INPUT.json` file.

### Deploy to Apify

```bash
npm install -g apify-cli
apify login
cd "c:\Wordpress Integration\wordpress-integration"
apify push
```

After deployment, open the Actor in Apify Console, fill the input form, and run it.

### Search phrases this Actor is built for

WordPress Apify integration, WordPress REST API Actor, WordPress post automation, WordPress content automation, upload WordPress posts from JSON, pull WordPress posts, export WordPress pages, delete WordPress post by ID, WordPress publishing automation.

# Actor input Schema

## `siteUrl` (type: `string`):

Full URL of your WordPress site, e.g. https://mysite.com

## `username` (type: `string`):

Your WordPress admin username

## `appPassword` (type: `string`):

Paste the WordPress Application Password exactly as WordPress shows it. Generate it at Users → Profile → Application Passwords. Do not use your normal login password or sandbox access code.

## `action` (type: `string`):

What should the actor do?

## `postType` (type: `string`):

Choose the WordPress content area to use. Keep 'post' for normal blog posts. Use 'page' for website pages, or enter a custom type only if your WordPress site uses one.

## `postStatus` (type: `string`):

Status to assign to newly created posts

## `maxPosts` (type: `integer`):

Limit number of posts fetched. Set to 0 for all posts.

## `deletePostId` (type: `integer`):

Required only for the delete\_post action

## `itemsToPush` (type: `array`):

JSON array of post objects with title, content, and optional meta fields

## Actor input object example

```json
{
  "siteUrl": "https://mysite.com",
  "action": "pull_posts",
  "postType": "post",
  "postStatus": "draft",
  "maxPosts": 0,
  "itemsToPush": [
    {
      "title": "New WordPress post from Apify",
      "content": "<p>This post was uploaded from Apify input.</p>\n{{image1}}\n<p>Text after the image.</p>",
      "featuredImageUrl": "https://picsum.photos/seed/wp-featured-image/1200/800.jpg",
      "imageUrls": [
        "https://picsum.photos/seed/wp-body-image/900/600.jpg"
      ],
      "imageOptions": [
        {
          "width": 900,
          "alt": "Example image uploaded from Apify"
        }
      ],
      "meta": {
        "source": "apify"
      }
    }
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

URL of the default dataset containing WordPress operation results.

# 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 = {
    "itemsToPush": [
        {
            "title": "New WordPress post from Apify",
            "content": "<p>This post was uploaded from Apify input.</p>\n{{image1}}\n<p>Text after the image.</p>",
            "featuredImageUrl": "https://picsum.photos/seed/wp-featured-image/1200/800.jpg",
            "imageUrls": [
                "https://picsum.photos/seed/wp-body-image/900/600.jpg"
            ],
            "imageOptions": [
                {
                    "width": 900,
                    "alt": "Example image uploaded from Apify"
                }
            ],
            "meta": {
                "source": "apify"
            }
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("new-world-scripts/wordpress-integration").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 = { "itemsToPush": [{
            "title": "New WordPress post from Apify",
            "content": """<p>This post was uploaded from Apify input.</p>
{{image1}}
<p>Text after the image.</p>""",
            "featuredImageUrl": "https://picsum.photos/seed/wp-featured-image/1200/800.jpg",
            "imageUrls": ["https://picsum.photos/seed/wp-body-image/900/600.jpg"],
            "imageOptions": [{
                    "width": 900,
                    "alt": "Example image uploaded from Apify",
                }],
            "meta": { "source": "apify" },
        }] }

# Run the Actor and wait for it to finish
run = client.actor("new-world-scripts/wordpress-integration").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "itemsToPush": [
    {
      "title": "New WordPress post from Apify",
      "content": "<p>This post was uploaded from Apify input.</p>\\n{{image1}}\\n<p>Text after the image.</p>",
      "featuredImageUrl": "https://picsum.photos/seed/wp-featured-image/1200/800.jpg",
      "imageUrls": [
        "https://picsum.photos/seed/wp-body-image/900/600.jpg"
      ],
      "imageOptions": [
        {
          "width": 900,
          "alt": "Example image uploaded from Apify"
        }
      ],
      "meta": {
        "source": "apify"
      }
    }
  ]
}' |
apify call new-world-scripts/wordpress-integration --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=new-world-scripts/wordpress-integration",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WordPress Integration",
        "description": "Manage WordPress content from Apify. Pull WordPress posts and pages, upload draft or published posts from JSON input, and delete WordPress posts by ID using the WordPress REST API.",
        "version": "0.1",
        "x-build-id": "mJ7wwqdEUB1dB4Zmb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/new-world-scripts~wordpress-integration/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-new-world-scripts-wordpress-integration",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/new-world-scripts~wordpress-integration/runs": {
            "post": {
                "operationId": "runs-sync-new-world-scripts-wordpress-integration",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/new-world-scripts~wordpress-integration/run-sync": {
            "post": {
                "operationId": "run-sync-new-world-scripts-wordpress-integration",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "siteUrl",
                    "username",
                    "appPassword",
                    "action"
                ],
                "properties": {
                    "siteUrl": {
                        "title": "WordPress site URL",
                        "type": "string",
                        "description": "Full URL of your WordPress site, e.g. https://mysite.com"
                    },
                    "username": {
                        "title": "WordPress username",
                        "type": "string",
                        "description": "Your WordPress admin username"
                    },
                    "appPassword": {
                        "title": "WordPress Application Password",
                        "type": "string",
                        "description": "Paste the WordPress Application Password exactly as WordPress shows it. Generate it at Users → Profile → Application Passwords. Do not use your normal login password or sandbox access code."
                    },
                    "action": {
                        "title": "Action to perform",
                        "enum": [
                            "pull_posts",
                            "upload_posts",
                            "pull_pages",
                            "delete_post",
                            "test_auth"
                        ],
                        "type": "string",
                        "description": "What should the actor do?",
                        "default": "pull_posts"
                    },
                    "postType": {
                        "title": "Where to upload content",
                        "type": "string",
                        "description": "Choose the WordPress content area to use. Keep 'post' for normal blog posts. Use 'page' for website pages, or enter a custom type only if your WordPress site uses one.",
                        "default": "post"
                    },
                    "postStatus": {
                        "title": "Post status when creating",
                        "enum": [
                            "draft",
                            "publish",
                            "pending",
                            "private"
                        ],
                        "type": "string",
                        "description": "Status to assign to newly created posts",
                        "default": "draft"
                    },
                    "maxPosts": {
                        "title": "Max posts to pull (0 = unlimited)",
                        "type": "integer",
                        "description": "Limit number of posts fetched. Set to 0 for all posts.",
                        "default": 0
                    },
                    "deletePostId": {
                        "title": "Post ID to delete",
                        "type": "integer",
                        "description": "Required only for the delete_post action"
                    },
                    "itemsToPush": {
                        "title": "Posts to upload",
                        "type": "array",
                        "description": "JSON array of post objects with title, content, and optional meta fields",
                        "items": {
                            "type": "object",
                            "properties": {
                                "title": {
                                    "title": "Post title",
                                    "description": "Title for the WordPress post",
                                    "type": "string"
                                },
                                "content": {
                                    "title": "Post content",
                                    "description": "HTML or plain text content for the WordPress post",
                                    "type": "string"
                                },
                                "featuredImageUrl": {
                                    "title": "Featured image URL",
                                    "description": "Optional main image URL to upload to WordPress and set as the post featured image",
                                    "type": "string"
                                },
                                "imageUrls": {
                                    "title": "Image URLs",
                                    "description": "Optional image URLs to upload to WordPress. Use {{image1}}, {{image2}}, etc. inside content to choose where each image appears. Images without placeholders are added at the end.",
                                    "type": "array",
                                    "items": {
                                        "type": "string"
                                    }
                                },
                                "imageOptions": {
                                    "title": "Image display options",
                                    "description": "Optional display settings for each imageUrl. First object applies to {{image1}}, second to {{image2}}, and so on.",
                                    "type": "array",
                                    "items": {
                                        "type": "object",
                                        "properties": {
                                            "width": {
                                                "title": "Image width",
                                                "description": "Optional image width in pixels",
                                                "type": "integer"
                                            },
                                            "height": {
                                                "title": "Image height",
                                                "description": "Optional image height in pixels",
                                                "type": "integer"
                                            },
                                            "alt": {
                                                "title": "Alt text",
                                                "description": "Optional image alt text",
                                                "type": "string"
                                            },
                                            "class": {
                                                "title": "CSS class",
                                                "description": "Optional CSS class for the image",
                                                "type": "string"
                                            }
                                        }
                                    }
                                },
                                "meta": {
                                    "title": "Post meta",
                                    "description": "Optional WordPress meta fields exposed through the REST API",
                                    "type": "object"
                                }
                            }
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```