Fix broken links across documentation to use correct /platform slugs

Author: TC-MO

sources/academy/ai/ai-agents.mdx

@@ -52,7 +52,7 @@ _Example input:_
 _Example output:_
 
 - Text response with insights
-- Data stored in Apify [Dataset](/platform/storage/dataset)
+- Data stored in Apify [Dataset](/platform/core-concepts/storage/dataset)
 
 :::note Agent memory
 

sources/academy/platform/actorization_playbook.mdx

@@ -58,14 +58,14 @@ You can Actorize various projects ranging from open-source libraries, throughout
 
 Use these criteria to decide if your project is a good candidate for Actorization:
 
-1. _Is it self-contained?_ Does the project work non-interactively, with a well-defined, preferably structured input and output format? Positive examples include various data processing utilities, web scrapers and other automation scripts. Negative examples are GUI applications or applications that run indefinitely. If you want to run HTTP APIs on Apify, you can do so using [Actor Standby](/platform/actors/development/programming-interface/standby).
-2. _Can the state be stored in Apify storages?_ If the application has state that can be stored in a small number of files it can utilize [key-value store](/platform/storage/key-value-store), or if it processes records that can be stored in Apify’s [request queue](/platform/storage/request-queue). If the output consists of one or many similar JSON objects, it can utilize [dataset](/platform/storage/dataset).
+1. _Is it self-contained?_ Does the project work non-interactively, with a well-defined, preferably structured input and output format? Positive examples include various data processing utilities, web scrapers and other automation scripts. Negative examples are GUI applications or applications that run indefinitely. If you want to run HTTP APIs on Apify, you can do so using [Actor Standby](/platform/using-actors/development/programming-interface/standby).
+2. _Can the state be stored in Apify storages?_ If the application has state that can be stored in a small number of files it can utilize [key-value store](/platform/core-concepts/storage/key-value-store), or if it processes records that can be stored in Apify’s [request queue](/platform/core-concepts/storage/request-queue). If the output consists of one or many similar JSON objects, it can utilize [dataset](/platform/core-concepts/storage/dataset).
 3. _Can it be containerized?_ The project needs to be able to run in a Docker container. Apify currently does not support GPU workloads. External services (e.g., databases) need to be managed by developer.
 4. _Can it use Apify tooling?_ Javascript/Typescript applications and Python applications can be Actorized with the help of the [Apify SDK](/sdk), which makes easy for your code to interacts with the Apify platform. Applications that can be run using just the CLI can also be Actorized using the Apify CLI by writing a simple shell script that retrieves user input using [Apify CLI](/cli/), then runs your application and sends the results back to Apify (also using the CLI). If your application is implemented differently, you can still call the [Apify API](/api/v2) directly - it’s just HTTP and pretty much every language has support for that but the implementation is less straightforward.
 
 ## Actorization guide
 
-This guide outlines the steps to convert your application into an Apify [Actor](/platform/actors). Follow the documentation links for detailed information - this guide provides an overview rather than exhaustive instructions.
+This guide outlines the steps to convert your application into an Apify [Actor](/platform/using-actors). Follow the documentation links for detailed information - this guide provides an overview rather than exhaustive instructions.
 
 ### 1. Add Actor metadata - the `.actor` folder
 
@@ -88,9 +88,9 @@ In case you're starting a new project, we strongly advise to start with a [templ
     :::
 
 
-The newly created `.actor` folder contains an `actor.json` file - a manifest of the Actor. See [documentation](/platform/actors/development/actor-definition/actor-json) for more details
+The newly created `.actor` folder contains an `actor.json` file - a manifest of the Actor. See [documentation](/platform/using-actors/development/actor-definition/actor-json) for more details
 
-You must also make sure your Actor has a Dockerfile and that it installs everything needed to successfully run your application. Check out [Dockerfile documentation](/platform/actors/development/actor-definition/dockerfile) by Apify. If you don't want to use these, you are free to use any image as the base of your Actor.
+You must also make sure your Actor has a Dockerfile and that it installs everything needed to successfully run your application. Check out [Dockerfile documentation](/platform/using-actors/development/actor-definition/dockerfile) by Apify. If you don't want to use these, you are free to use any image as the base of your Actor.
 
 When launching the Actor, the Apify platform will simply run your Docker image. This means that a) you need to configure the `ENTRYPOINT` and `CMD` directives so that it launches your application and b) you can test your image locally using Docker.
 
@@ -100,7 +100,7 @@ These steps are the bare minimum you need to run your code on Apify. The rest of
 
 Most Actors accept an input and produce an output. As part of Actorization, you need to define the input and output structure of your application.
 
-For detailed information, read the docs for [input schema](/platform/actors/development/actor-definition/input-schema), [dataset schema](/platform/actors/development/actor-definition/dataset-schema), and general [storage](/platform/storage).
+For detailed information, read the docs for [input schema](/platform/using-actors/development/actor-definition/input-schema), [dataset schema](/platform/using-actors/development/actor-definition/dataset-schema), and general [storage](/platform/core-concepts/storage).
 
 
 #### Design guidelines
@@ -113,11 +113,11 @@ For detailed information, read the docs for [input schema](/platform/actors/deve
 
 ### 3. Handle state persistence (optional)
 
-If your application performs a number of well-defined subtasks, the [request queue](/platform/storage/request-queue) lets you pause and resume execution on job restart. This is important for long-running jobs that might be migrated between servers at some point. In addition, this allows the Apify platform to display the progress to your users in the UI.
+If your application performs a number of well-defined subtasks, the [request queue](/platform/core-concepts/storage/request-queue) lets you pause and resume execution on job restart. This is important for long-running jobs that might be migrated between servers at some point. In addition, this allows the Apify platform to display the progress to your users in the UI.
 
 A lightweight alternative to the request queue is simply storing the state of your application as a JSON object in the key-value store and checking for that when your Actor is starting.
 
-Fully-fledged Actors will often combine these two approaches for maximum reliability. More on this topic you find in the [state persistence](/platform/actors/development/builds-and-runs/state-persistence) article.
+Fully-fledged Actors will often combine these two approaches for maximum reliability. More on this topic you find in the [state persistence](/platform/using-actors/development/builds-and-runs/state-persistence) article.
 
 ### 4. Write Actorization code
 
@@ -127,12 +127,12 @@ Unless you’re writing an application targeted directly on the Apify platform,
 
 Apify provides SDKs for [Javascript](/sdk/js/) and [Python](/sdk/python/) plus a [Apify CLI](/cli/) allowing an easy interaction with Apify platform from command line.
 
-Check out [programming interface](/platform/actors/development/programming-interface/) documentation article for details on interacting with the Apify platform in your Actor's code.
+Check out [programming interface](/platform/using-actors/development/programming-interface/) documentation article for details on interacting with the Apify platform in your Actor's code.
 
 ### 5. Deploy the Actor
 
-Deployment to Apify platform can be done easily via `apify push` command of [Apify CLI](/cli/) and for details see [deployment](/platform/actors/development/deployment) documentation.
+Deployment to Apify platform can be done easily via `apify push` command of [Apify CLI](/cli/) and for details see [deployment](/platform/using-actors/development/deployment) documentation.
 
 ### 6. Publish and monetize
 
-For details on publishing the Actor in [Apify Store](https://apify.com/store) see the [Publishing and monetization](/platform/actors/publishing). You can also follow our guide on [How to create an Actor README](/academy/actor-marketing-playbook/actor-basics/how-to-create-an-actor-readme) and [Actor marketing playbook](/academy/actor-marketing-playbook).
+For details on publishing the Actor in [Apify Store](https://apify.com/store) see the [Publishing and monetization](/platform/publishing-and-monetization/publish). You can also follow our guide on [How to create an Actor README](/academy/actor-marketing-playbook/actor-basics/how-to-create-an-actor-readme) and [Actor marketing playbook](/academy/actor-marketing-playbook).

sources/academy/platform/deploying_your_code/deploying.md

@@ -63,4 +63,4 @@ The next step is to test your Actor and experiment with the vast amount of featu
 
 ## Wrap up {#next}
 
-That's it! In this short section, you've learned how to take your code written in any programming language and turn it into a usable Actor that can run on the Apify platform! The next step is to start looking into the [paid Actors](/platform/actors/publishing) program, which allows you to monetize your work.
+That's it! In this short section, you've learned how to take your code written in any programming language and turn it into a usable Actor that can run on the Apify platform! The next step is to start looking into the [paid Actors](/platform/publishing-and-monetization/publish) program, which allows you to monetize your work.

sources/academy/platform/deploying_your_code/input_schema.md

@@ -9,7 +9,7 @@ slug: /deploying-your-code/input-schema
 
 ---
 
-Though writing an [input schema](/platform/actors/development/actor-definition/input-schema) for an Actor is not a required step, it is most definitely an ideal one. The Apify platform will read the **INPUT_SCHEMA.json** file within the root of your project and generate a user interface for entering input into your Actor, which makes it significantly easier for non-developers (and even developers) to configure and understand the inputs your Actor can receive. Because of this, we'll be writing an input schema for our example Actor.
+Though writing an [input schema](/platform/using-actors/development/actor-definition/input-schema) for an Actor is not a required step, it is most definitely an ideal one. The Apify platform will read the **INPUT_SCHEMA.json** file within the root of your project and generate a user interface for entering input into your Actor, which makes it significantly easier for non-developers (and even developers) to configure and understand the inputs your Actor can receive. Because of this, we'll be writing an input schema for our example Actor.
 
 > Without an input schema, the users of our Actor will have to provide the input in JSON format, which can be problematic for those who are not familiar with JSON.
 
@@ -51,7 +51,7 @@ Each property's key corresponds to the name we're expecting within our code, whi
 
 ## Property types & editor types {#property-types}
 
-Within our new **numbers** property, there are two more fields we must specify. Firstly, we must let the platform know that we're expecting an array of numbers with the **type** field. Then, we should also instruct Apify on which UI component to render for this input property. In our case, we have an array of numbers, which means we should use the **json** editor type that we discovered in the ["array" section](/platform/actors/development/actor-definition/input-schema/specification/v1#array) of the input schema documentation. We could also use **stringList**, but then we'd have to parse out the numbers from the strings.
+Within our new **numbers** property, there are two more fields we must specify. Firstly, we must let the platform know that we're expecting an array of numbers with the **type** field. Then, we should also instruct Apify on which UI component to render for this input property. In our case, we have an array of numbers, which means we should use the **json** editor type that we discovered in the ["array" section](/platform/using-actors/development/actor-definition/input-schema/specification/v1#array) of the input schema documentation. We could also use **stringList**, but then we'd have to parse out the numbers from the strings.
 
 ```json
 {
@@ -102,8 +102,8 @@ Here is what the input schema we wrote will render on the platform:
 
 Later on, we'll be building more complex input schemas, as well as discussing how to write quality input schemas that allow the user to understand the Actor and not become overwhelmed.
 
-It's not expected to memorize all of the fields that properties can take or the different editor types available, which is why it's always good to reference the [input schema documentation](/platform/actors/development/actor-definition/input-schema) when writing a schema.
+It's not expected to memorize all of the fields that properties can take or the different editor types available, which is why it's always good to reference the [input schema documentation](/platform/using-actors/development/actor-definition/input-schema) when writing a schema.
 
 ## Next up {#next}
 
-In the [next lesson](/platform/actors/development/actor-definition/dataset-schema), we'll learn how to generate an appealing Overview table to display our Actor's results in real time, so users can get immediate feedback about the data being extracted.
+In the [next lesson](/platform/using-actors/development/actor-definition/dataset-schema), we'll learn how to generate an appealing Overview table to display our Actor's results in real time, so users can get immediate feedback about the data being extracted.

sources/academy/platform/deploying_your_code/inputs_outputs.md

@@ -19,7 +19,7 @@ An important thing to understand regarding inputs and outputs is that they are r
 
 ## A bit about storage {#about-storage}
 
-You can read/write your inputs/outputs: to the [key-value store](/platform/storage/key-value-store), or to the [dataset](/platform/storage/dataset). The key-value store can be used to store any sort of unorganized/unrelated data in any format, while the data pushed to a dataset typically resembles a table with columns (fields) and rows (items). Each Actor's run is allocated both a default dataset and a default key-value store.
+You can read/write your inputs/outputs: to the [key-value store](/platform/core-concepts/storage/key-value-store), or to the [dataset](/platform/core-concepts/storage/dataset). The key-value store can be used to store any sort of unorganized/unrelated data in any format, while the data pushed to a dataset typically resembles a table with columns (fields) and rows (items). Each Actor's run is allocated both a default dataset and a default key-value store.
 
 When running locally, these storages are accessible through the **storage** folder within your project's root directory, while on the platform they are accessible via Apify's API.
 

sources/academy/platform/deploying_your_code/output_schema.md

@@ -160,7 +160,7 @@ const results = {
 
 Great! Now that everything is set up, it's time to run the Actor and admire your Actor's brand new output tab.
 
-> Need some extra guidance? Visit the [dataset schema documentation](/platform/actors/development/actor-definition/dataset-schema) for more detailed information about how to implement this feature.
+> Need some extra guidance? Visit the [dataset schema documentation](/platform/using-actors/development/actor-definition/dataset-schema) for more detailed information about how to implement this feature.
 
 A few seconds after running the Actor, you should see its results displayed in the `Overview` table.
 

sources/academy/platform/expert_scraping_with_apify/actors_webhooks.md

@@ -27,7 +27,7 @@ Webhooks are a powerful tool that can be used for just about anything. You can s
 
 Prior to moving forward, please read over these resources:
 
-- Read about [running Actors, handling Actor inputs, memory and CPU](/platform/actors/running).
+- Read about [running Actors, handling Actor inputs, memory and CPU](/platform/using-actors/running).
 - Learn about [Actor webhooks](/platform/integrations/webhooks), which we will implement in the next lesson.
 - Learn [how to run Actors](/academy/api/run-actor-and-retrieve-data-via-api) using Apify's REST API.
 

sources/academy/platform/expert_scraping_with_apify/bypassing_anti_scraping.md

@@ -20,7 +20,7 @@ You might have already noticed that we've been using the **RESIDENTIAL** proxy g
 ## Learning 🧠 {#learning}
 
 - Skim [this page](https://apify.com/proxy) for a general idea of Apify Proxy.
-- Give the [proxy documentation](/platform/proxy) a solid readover (feel free to skip most of the examples).
+- Give the [proxy documentation](/platform/core-concepts/proxy) a solid readover (feel free to skip most of the examples).
 - Check out the [anti-scraping guide](../../webscraping/anti_scraping/index.md).
 - Gain a solid understanding of the [SessionPool](https://crawlee.dev/api/core/class/SessionPool).
 - Look at a few Actors on the [Apify store](https://apify.com/store). How are they utilizing proxies?

sources/academy/platform/expert_scraping_with_apify/migrations_maintaining_state.md

@@ -19,14 +19,14 @@ When a migration happens, you want to do a so-called "state transition", which m
 
 ## Learning 🧠 {#learning}
 
-Read this [article](/platform/actors/development/builds-and-runs/state-persistence) on migrations and dealing with state transitions.
+Read this [article](/platform/using-actors/development/builds-and-runs/state-persistence) on migrations and dealing with state transitions.
 
 Before moving forward, read about Actor [events](/sdk/js/docs/upgrading/upgrading-to-v3#events) and how to listen for them.
 
 ## Knowledge check 📝 {#quiz}
 
 1. Actors have an option in the **Settings** tab to **Restart on error**. Would you use this feature for regular Actors? When would you use this feature?
-2. Migrations happen randomly, but by [aborting **gracefully**](/platform/actors/running/runs-and-builds#aborting-runs), you can simulate a similar situation. Try this out on the platform and observe what happens. What changes occur, and what remains the same for the restarted Actor's run?
+2. Migrations happen randomly, but by [aborting **gracefully**](/platform/using-actors/running/runs-and-builds#aborting-runs), you can simulate a similar situation. Try this out on the platform and observe what happens. What changes occur, and what remains the same for the restarted Actor's run?
 3. Why don't you (usually) need to add any special migration handling code for a standard crawling/scraping Actor? Are there any features in the Crawlee/Apify SDK that handle this under the hood?
 4. How can you intercept the migration event? How much time do you have after this event happens and before the Actor migrates?
 5. When would you persist data to the default key-value store instead of to a named key-value store?

sources/academy/platform/expert_scraping_with_apify/solutions/handling_migrations.md

@@ -231,7 +231,7 @@ That's everything! Now, even if the Actor migrates (or is gracefully aborted and
 
 **A:** It's not best to use this option by default. If it fails, there must be a reason, which would need to be thought through first - meaning that the edge case of failing should be handled when resurrecting the Actor. The state should be persisted beforehand.
 
-**Q: Migrations happen randomly, but by [aborting gracefully](/platform/actors/running/runs-and-builds#aborting-runs), you can simulate a similar situation. Try this out on the platform and observe what happens. What changes occur, and what remains the same for the restarted Actor's run?**
+**Q: Migrations happen randomly, but by [aborting gracefully](/platform/using-actors/running/runs-and-builds#aborting-runs), you can simulate a similar situation. Try this out on the platform and observe what happens. What changes occur, and what remains the same for the restarted Actor's run?**
 
 **A:** After aborting or throwing an error mid-process, it manages to start back from where it was upon resurrection.