Put the work that depends on the page—such as reading the DOM or rendering an image—inside the callback passed to page.open(url, callback). Check that the callback status is success first. This waits for PhantomJS’s page-load callback, but it does not guarantee that a site’s later AJAX requests or application updates have finished. For those, wait for the particular content you need to appear, with a timeout so the script cannot wait forever.
Wait for PhantomJS’s page-load callback
page.open() is asynchronous: it starts opening the URL and calls your callback when the page-load event finishes. PhantomJS passes the callback a status of success or fail. Put any work that relies on the loaded page inside that callback, and do not render or read page data before it runs.
Basic working example
var page = require('webpage').create();
page.open('https://example.com', function (status) {
if (status !== 'success') {
console.log('Unable to load the page');
phantom.exit(1);
return;
}
console.log(page.title);
page.render('page.png');
phantom.exit();
});The example checks the result before accessing the page, renders only after a successful load callback, and exits after the dependent work. Replace the URL and output filename with the ones for your task. PhantomJS scripts need to call phantom.exit() eventually; otherwise the process will not terminate.
Why the callback matters
Starting page.open() does not mean the page is already available to the next line of your script. If you call phantom.exit() immediately after starting the request, the process can end before the callback runs. The same timing issue applies to code that reads the title, inspects elements, or renders a screenshot: keep it in the callback or in a later callback that represents the condition you need.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →#1 Best Overall
What “the full page has loaded” does—and does not—mean
The page.open() callback is a useful boundary for the initial document load. It is not a universal “everything on this website is ready” signal. A page may update after load through AJAX or other application code, and content that appears later may not be present when the initial callback runs.
Choose the next step based on the output you need. If the page is static and the initial document is sufficient, the successful load callback may be enough. If a screenshot must contain search results, a dashboard value, or another element populated after load, wait for that particular element or value instead of assuming the initial callback covers it.
Use a page-specific readiness condition
A practical approach is to poll for an observable condition, such as a target element appearing or its text becoming non-empty. The following example illustrates that pattern. Set the selector and readiness test to match the page you control, and set a finite timeout appropriate to the task. The timeout below is an example value, not a PhantomJS-prescribed delay.
Rank #2
var page = require('webpage').create();
var targetSelector = '#results';
var deadline;
var pollTimer;
page.open('https://example.com', function (status) {
if (status !== 'success') {
console.log('Unable to load the page');
phantom.exit(1);
return;
}
deadline = Date.now() + 10000;
pollTimer = setInterval(function () {
var ready = page.evaluate(function (selector) {
var element = document.querySelector(selector);
return !!element && element.textContent.trim().length > 0;
}, targetSelector);
if (ready) {
clearInterval(pollTimer);
page.render('page.png');
phantom.exit();
return;
}
if (Date.now() >= deadline) {
clearInterval(pollTimer);
console.log('Timed out waiting for ' + targetSelector);
phantom.exit(1);
}
}, 100);
});This checks for a non-empty target rather than merely waiting a fixed amount of time. Adapt the condition if the element exists before its data is ready—for example, check for a particular text value or a page-specific state. A timeout prevents a missing element or failed update from leaving the script running indefinitely. Choose the timeout based on the page and the consequences of waiting; no single duration is correct for every site.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteThe example uses PhantomJS’s timer and page-evaluation APIs to demonstrate the condition-based pattern. It is not a guarantee that any arbitrary site will expose a reliable readiness marker. If the page has no observable signal for completion, a bounded delay can be used as a fallback, but it only waits for the chosen interval; it cannot prove the application has finished.
Wait for an included script before using it
If you add a library with page.includeJs, place work that depends on that library in the include callback. Otherwise, the script may try to use the library before it has loaded. Likewise, do not exit the PhantomJS process outside the callback if the dependent work still needs to run.
Rank #3
var page = require('webpage').create();
page.open('https://example.com', function (status) {
if (status !== 'success') {
console.log('Unable to load the page');
phantom.exit(1);
return;
}
page.includeJs('https://example.com/library.js', function () {
// Use the included library or perform dependent work here.
console.log('Page and included script are ready for this step');
page.render('page.png');
phantom.exit();
});
});Use the actual library URL required by your page. If the include callback is never reached because the script cannot load, diagnose that failure rather than assuming the library is available.
Set a resource timeout before opening the page
For slow or stalled resource requests, configure page.settings.resourceTimeout before calling page.open(). The value is in milliseconds. PhantomJS calls page.onResourceTimeout when a requested resource times out, which gives the script a way to observe that event.
var page = require('webpage').create();
page.settings.resourceTimeout = 15000;
page.onResourceTimeout = function (request) {
console.log('Resource timed out: ' + request.url);
};
page.open('https://example.com', function (status) {
if (status !== 'success') {
console.log('Unable to load the page');
phantom.exit(1);
return;
}
page.render('page.png');
phantom.exit();
});The 15,000-millisecond setting here is an example, not a universal recommendation. Resource timeout bounds an individual request; it is not a signal that application-specific content is ready. Settings for resources apply during the initial page.open(), so changing resourceTimeout after opening the URL will not affect that initial load.
Choose the right waiting strategy
| Strategy | What it tells you | Best fit | Main risk |
|---|---|---|---|
Successful page.open() callback |
The initial page-load callback completed successfully. | Static pages or work that only needs the initial document. | Later application updates may not have completed. |
| Page-specific condition | The particular element or state your script checks is present. | Pages that populate needed content after initial load. | The condition may be wrong, or the page may never reach it; use a timeout. |
| Bounded delay fallback | The selected amount of time has elapsed. | Cases with no usable readiness marker, as a fallback. | It can be too short or waste time; elapsed time does not prove readiness. |
Start with the successful load callback, then add the narrowest additional condition that matches the output you need. A condition tied to actual content is generally more informative than an arbitrary delay. The PhantomJS documentation does not define one readiness condition or delay that works for every website.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Troubleshoot pages that still appear incomplete
The callback reports failure
Check the callback status before reading or rendering. When it is not success, do not treat the page as loaded; log the failure and exit with a nonzero status, as in the examples. If resources are slow or stalled, set a suitable resource timeout before opening the page and log resource timeout events to help identify the request involved.
The screenshot is missing dynamic content
This usually means the initial load callback ran before the application produced the content you need. Add a condition for the target element or its populated value, and keep a timeout. Confirm that your condition describes readiness rather than mere existence if the page creates an empty placeholder early.
The script exits before rendering
Move phantom.exit() to after the dependent action. If that action depends on page.open() or page.includeJs, perform it inside the appropriate callback. Exiting immediately after starting an asynchronous operation can stop the process before that operation completes.
Changing the timeout had no effect
Make sure page.settings.resourceTimeout is assigned before page.open(). It applies to the initial open, not retroactively to a load already in progress. Also distinguish a resource timeout from an application-ready condition: the first bounds a request, while the second determines whether the page has produced the output your script needs.
Or skip the browser setup
If your goal is to capture a website rather than maintain a PhantomJS script, ScreenshotNeo offers a screenshot API and MCP server. A single GET request can return a PNG, JPEG, WebP, or PDF. Its cleanup steps can accept cookie or consent banners and remove more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be turned off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and responses identify the page verdict and billing status in headers.
For example, this cURL request saves a WebP screenshot of the target page. Replace the example URL with the page you want to capture and provide your API key:
Free tools Windows power users keep installed
One-click scans. No signup required.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for request options. The service also has an MCP server with take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots. These are plan allowances and prices, not a claim that the API is a drop-in replacement for every PhantomJS script or page-specific workflow.
Sign up free for 1,000 screenshots a month, with no card required.
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.
