Recommended Free Tools
Direct answer: In Apify Console, open Actors → Develop new → Import from Git → GitHub, authorize the GitHub account or organization, and select the repository. Apify creates an Actor linked to that repository. It normally builds from the repository’s default branch; you can change the branch in the Actor’s Source settings. Private repositories need an Apify deployment key, and a push rebuilds the Actor only when automated builds are enabled.
This guide covers the Console workflow, private repositories, branches, Docker requirements, automatic and manual builds, CLI deployment, CI pipelines, troubleshooting, and a browser-free alternative for generating clean screenshots.
What an Apify Git-sourced Actor is
A Git-sourced Actor keeps your scraper in your existing repository instead of copying files into Apify’s Web IDE. Apify stores the repository URL and clones the source when it builds an Actor version. The resulting image runs as a normal Actor, so the runtime does not change merely because the source is hosted on GitHub.
There are two deployment models to keep distinct:
- Git source: Apify records the repository location and obtains the code during a build.
- Apify-hosted source: the CLI command
apify pushuploads source files to an Actor version and starts a build.
Use the Git source when the repository should remain the canonical location. Use a CI pipeline or apify push when you need tests, generated files, or other controlled steps before an image is built.
#1 Best Overall
Prerequisites and repository checks
Accounts and permissions
- An Apify account with permission to create or edit Actors.
- Access to the GitHub repository, including authorization for the relevant personal account or organization.
- A repository that contains a buildable Actor project, including a Dockerfile. The standard Node.js template commonly uses
main.jsandpackage.json, but your project may use different files.
Make the repository buildable
Before connecting it, verify locally that dependencies install, the scraper starts with its expected command, and every file required at build time is committed. Keep secrets out of Git; supply them as Actor input, environment variables, or Apify secrets instead.
If the scraper is in a monorepo, decide which directory is the Actor’s build context. The source configuration can identify a subdirectory and, where required, set dockerContextDir so Docker receives the correct files.
Create the Actor from GitHub in Apify Console
- Sign in to Apify Console and open Actors.
- Choose Develop new.
- Select Import from Git, then choose GitHub.
- Authorize Apify for the GitHub account, organization, or repository that should be connected.
- Select the repository. Apify creates the Actor as soon as a repository is selected.
The Actor now has a Git-backed source. Open its source configuration before the first production build and confirm the repository, branch, directory, and build settings.
Choose the branch and source directory
Default branch behavior
A newly linked Actor uses the repository’s default branch. If the scraper lives on develop, release, or another branch, change the branch in the Actor’s Source settings. Do not assume that selecting a repository automatically follows the branch you last edited.
Branch, tag, and subdirectory references
For a general Git repository source, the source URL can identify a branch or tag and a subdirectory with a fragment. The documented form is:
REPOSITORY_URL#develop:some/dirHere, develop identifies the branch or tag and some/dir is the directory containing the Actor project. Use a tag when you want reproducible builds; use a branch when you want new commits to flow into the Actor.
Connect a private repository
Private access is a cloning requirement, not a different Actor runtime. Configure it only when the source cannot be read publicly.
- Set the Actor source type to Git repository.
- Choose or create an Apify deployment key.
- Copy the key’s public SSH key into the repository’s GitHub deploy-key settings.
- Grant the key read-only access.
- Set the source URL to the repository’s SSH Git URL.
- Save the source and start a build.
The deployment key lets Apify clone and build the repository without giving it write permission. If cloning fails, check that the public key was added to the same repository, that read access is enabled, and that the source URL uses SSH rather than an HTTPS URL requiring an interactive password.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Configure builds after a Git push
Automatic builds
When automated builds are enabled for the relevant Actor version, a push to the configured repository and branch starts a build. The push itself is not proof that a new image exists: automatic-build settings are version-specific. Confirm the setting in the Actor’s build or source configuration.
Manual builds
With automated builds disabled, a push updates Git but does not start an Apify build. Start one from the Console, through the Build Actor endpoint, or with the CLI command:
apify actors buildManual mode is useful when several commits should be reviewed together, when builds are expensive, or when a release operator must approve the exact source revision.
Versioning and reproducibility
Build settings apply per Actor version. Record which branch or tag each version uses, and inspect build logs after changing source settings. A successful clone does not guarantee a successful image: dependency installation, Docker instructions, and runtime startup still have to pass.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Dockerfile and project layout
Apify’s source-type guidance requires a Dockerfile for Actors. A minimal repository therefore normally includes:
your-repository/
├── Dockerfile
├── package.json
├── main.js
└── .actor/
└── actor.jsonThe names are examples, not a rule that every scraper must be Node.js. Match the Dockerfile’s working directory, install commands, entry point, and exposed files to your language and framework. If the Dockerfile expects /app but the selected monorepo directory contains only a nested project, set the build context accordingly.
Test the first build and run
- Start a build from the Actor’s Console page after confirming the branch and directory.
- Read the clone step first. It should show the intended repository and revision.
- Check dependency installation for missing lockfiles, private packages, or incompatible runtime versions.
- Check the Docker build for incorrect paths or an absent Dockerfile.
- Run the Actor with a small test input and inspect its dataset, key-value store, and log output.
Keep the first input narrow: one URL, a short pagination limit, or a test domain. This separates deployment problems from scraper logic and avoids launching an expensive crawl while the image is still being validated.
CLI and CI alternatives
Apify CLI
The Apify CLI quick start supports creating an Actor from the command line with apify create and connecting a Git host. After that setup, a Git push can deploy and build the Git-sourced Actor according to the configured workflow. This route suits developers who prefer terminal-based project creation and repeatable scripts.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Continuous integration
Use CI when a repository push should first run linting, unit tests, integration tests, security checks, or generated-code steps. Apify documents a CI deployment pattern using:
.actor/actor.jsonto describe the Actor project.- A protected Apify API token stored as a CI secret.
- The official
apify/push-actor-action.
A typical pipeline checks out the commit, runs tests, and only then pushes the Actor source. This gives you control that a direct Git source build does not provide by itself.
Which deployment route should you choose?
| Route | Setup effort | Build control | Private repository | Pre-build tests |
|---|---|---|---|---|
| Console GitHub import | Lowest | Branch, source, and build settings | Deployment key required | Not automatically supplied |
| Apify CLI | Command-line setup | Scriptable deployment | Use the configured Git credentials | Add your own commands |
| CI deployment | Highest initial setup | Full pipeline control | Store credentials as protected secrets | Yes, before push |
Choose direct Git integration for the shortest path from repository to Actor. Choose CI when a merge must pass checks before a build. Choose the CLI when your team wants the same operations in local scripts or release automation.
Troubleshooting common failures
The repository is not listed
Cause: Apify was not authorized for the account or organization that owns the repository, or GitHub access was limited to selected repositories.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsFix: Repeat the GitHub authorization flow and grant access to the specific organization or repository. Then reopen the import screen.
Clone fails for a private repository
Cause: The deployment key is missing, attached to another repository, or used with an HTTPS URL.
Fix: Add the public key as a read-only deploy key on the target repository and use its SSH URL.
The wrong branch is built
Cause: The Actor still follows the repository’s default branch.
Fix: Set the intended branch or tag in Source settings, save, and start a new build.
A push changed Git but no build appeared
Cause: Automated builds are disabled for that Actor version, or the push went to a different branch.
Fix: Verify the configured branch and automated-build setting. Start a manual build if that is the intended release process.
Docker reports a missing file
Cause: The selected directory is not the Docker build context, or the Dockerfile references paths outside it.
Best Value
Fix: Correct the source subdirectory and dockerContextDir, then ensure all referenced files are committed.
The image builds but the run exits immediately
Cause: The Docker entry point, required environment variable, or Actor input handling is incorrect.
Fix: Run the same start command locally, inspect the Actor log’s first error, and provide required configuration through Actor input or environment settings.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Operational and security considerations
- Pin production builds to reviewed commits or tags when reproducibility matters.
- Use read-only deployment keys for private source access.
- Keep API tokens, login cookies, and proxy credentials out of the repository and logs.
- Set request limits and respectful crawl rates in the scraper; Git deployment does not change a target site’s terms or robots policy.
- Watch build logs after dependency updates, because a successful previous image does not validate a new lockfile or base image.
Or skip the browser setup
If your Actor’s job is to capture web pages rather than parse HTML, ScreenshotNeo provides a single HTTP request instead of maintaining a browser in your scraper. It accepts cookie and consent banners like a visitor, then removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed; response headers identify the page verdict and whether the request was billed. Its MCP server also lets Claude, Cursor, or another MCP client call take_screenshot, get_page_info, and capture_pdf.
See the full parameter list in the ScreenshotNeo documentation. This cURL request saves a WebP image:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpPython:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);You can request PNG, JPEG, WebP, or PDF and configure full-page or element captures, device and viewport settings, retina scale, dark mode, custom CSS or JavaScript, clicks, waits, blocked resources, headers, cookies, user agent, timezone, geolocation, transparent backgrounds, resizing, caching TTL, signed image links, asynchronous webhooks, bulk capture of up to 100 URLs per call, and usage reporting. Plans include 1,000 screenshots per month free with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.
Frequently Asked Questions
Does importing a repository copy my source into Apify?
No. A Git-sourced Actor keeps the repository URL and obtains the code when Apify builds an Actor version; this differs from uploading source with apify push.
Can I use a tag instead of a branch?
Yes. The Git source reference can identify a tag, which is useful when you need a fixed, reviewable revision rather than the latest commit on a moving branch.
Free tools Windows power users keep installed
One-click scans. No signup required.
Do I need a separate Actor for a private repository?
No. Private access changes the cloning configuration only: add a read-only deployment key and use the repository’s SSH URL.
Where should CI credentials be stored?
Store the Apify API token as a protected secret in your CI system, not in .actor/actor.json, source files, or build logs.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
