API:REST API/Referenzen
Die REST-API lässt dich durch das Absenden von HTTP-Abfragen an einzigartige URLs mit MediaWiki interagieren. Du kannst die API nutzen, um Apps und Skripte zu erstellen, die Wiki-Seiten und Versionsgeschichten durchsuchen.
Suche
MediaWiki Version: | ≥ 1.35 |
Suchergebnisobjekt
Das Suchergebnisobjekt repräsentiert eine Wiki-Seite, die mit der angefragten Suche übereinstimmt.
Beispiel
{
"id": 38930,
"key": "Jupiter",
"title": "Jupiter",
"excerpt": "<span class=\"searchmatch\">Jupiter</span> is the fifth planet from the Sun and the largest in the Solar System. It is a gas giant with a mass one-thousandth that of the Sun, but two-and-a-half",
"matched_title": null,
"description": "fifth planet from the Sun and largest planet in the Solar System",
"thumbnail": {
"mimetype": "image/jpeg",
"size": null,
"width": 200,
"height": 200,
"duration": null,
"url": "//upload.wikimedia.org/wikipedia/commons/thumb/2/2b/Jupiter_and_its_shrunken_Great_Red_Spot.jpg/200px-Jupiter_and_its_shrunken_Great_Red_Spot.jpg"
}
}
Schema
id
required | integer |
Seitenkennung
|
key
required | string |
Seitentitel in URL-freundlichem Format
|
title
required | string |
Seitentitel in lesefreundlichem Format
|
excerpt
required | string |
|
matched_title
optional | string |
Der Titel der Seite, von der aus weitergeleitet wird, wenn der Suchbegriff ursprünglich mit einer Weiterleitungsseite übereinstimmt oder null, wenn der Suchbegriff nicht mit einer Weiterleitungsseite übereinstimmt.
|
description
required | string |
|
thumbnail
required | object |
Information über das Vorschaubild der Seite oder null , wenn kein Vorschaubild existiert.
|
Seiten suchen
Path | /search/page?q=search terms
|
Method | GET
|
---|---|---|---|
Content type | application/json
|
Returns | pages -Objekt, das das Array der Suchergebnisse enthält
|
Sucht nach Titeln von Wiki-Seiten und Inhalten für die angegebenen Suchbegriffe und gibt passende Seiten aus.
Dieser Endpunkt nutzt die Suchmaschine, die in den Konfigurationseinstellungen von $wgSearchType konfiguriert ist und gibt die Ergebnisse in den von $wgNamespacesToBeSearchedDefault konfigurierten Namensräumen aus.
Beispiele
curl
# Search English Wikipedia for up to 20 pages containing information about Jupiter
$ curl "https://en.wikipedia.org/w/rest.php/v1/search/page?q=jupiter&limit=20"
Python
# Search English Wikipedia for up to 20 pages containing information about Jupiter
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/search/page'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
params = {
'q': 'jupiter',
'limit': '20'
}
response = requests.get(url, headers=headers, params=params)
data = response.json()
print(data)
PHP
<?php
/*
Search English Wikipedia for up to 20 pages containing information about Jupiter
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/search/page";
$params = [ "q" => "jupiter", "limit" => "20" ];
$url = $url . "?" . http_build_query( $params );
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Search English Wikipedia for up to 20 pages containing information about Jupiter
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/search/page";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
let params = {
'q': 'jupiter',
'limit': '20'
};
let query = Object.keys(params)
.map(k => k + '=' + encodeURIComponent(params[k]))
.join('&');
url = url + '?' + query;
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
q
required | query | string |
Suchbegriffe |
limit
optional | query | string |
Maximale Anzahl auszugebender Ergebnisse, zwischen 1 und 100. Standard: 50. |
Antworten
200 | Erfolg: Ergebnisse gefunden. Gibt ein pages -Objekt aus, das ein Array der Suchergebnisse enthält.
|
---|---|
200 | Erfolg: Keine Ergebnisse gefunden. Gibt ein pages -Objekt aus, das ein leeres Array enthält.
|
400 | Abfrage-Parameter nicht gesetzt. Setze den Parameter q .
|
400 | Ungültiges Limit abgefragt. Setze den Parameter limit auf einen Wert zwischen 1 und 100.
|
500 | Suchfehler |
Automatische Vervollständigung des Seitentitels
Path | /search/title?q=search terms
|
Method | GET
|
---|---|---|---|
Content type | application/json
|
Returns | pages object containing array of search results
|
Sucht Titel von Wiki-Seiten und gibt Treffer zwischen dem Beginn eines Titels und den angegebenen Suchbegriffen aus. Du kannst diesen Endpunkt für eine Typeahead-Suche nutzen, die automatisch relevante Seiten anhand ihres Titels vorschlägt.
Dieser Endpunkt nutzt die Suchmaschine, die in den Konfigurationseinstellungen von $wgSearchType konfiguriert ist und gibt die Ergebnisse in den von $wgNamespacesToBeSearchedDefault konfigurierten Namensräumen aus. Die Ergebnisse können sich abhängig vom konfigurierten Such-Backend unterscheiden. Während das Standard-Backend nur grundlegendes Case-Folding und Präfix-Treffer anwendet, können fortgeschrittene Backends komplexere Variationen anwenden. Im Fall von CirrusSearch basieren Treffer beispielsweise auf dem Elastic-Search-Vervollständigungsvorschlag.
Beispiele
curl
# Search English Wikipedia for up to 5 pages with titles that start with "solar"
$ curl "https://en.wikipedia.org/w/rest.php/v1/search/title?q=solar&limit=5"
Python
# Search English Wikipedia for up to 5 pages with titles that start with "solar"
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/search/title'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
params = {
'q': 'solar',
'limit': '5'
}
response = requests.get(url, headers=headers, params=params)
data = response.json()
print(data)
PHP
<?php
/*
Search English Wikipedia for up to 5 pages with titles that start with "solar"
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/search/title";
$params = [ "q" => "solar", "limit" => "5" ];
$url = $url . "?" . http_build_query( $params );
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Search English Wikipedia for up to 5 pages with titles that start with "solar"
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/search/title";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
let params = {
'q': 'solar',
'limit': '5'
};
let query = Object.keys(params)
.map(k => k + '=' + encodeURIComponent(params[k]))
.join('&');
url = url + '?' + query;
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
q
required | query | string |
Suchbegriffe |
limit
optional | query | string |
Antworten
200 | |
---|---|
200 | |
400 | |
400 | |
500 |
Seiten
MediaWiki Version: | ≥ 1.35 |
Seiten-Objekt
Das Seiten-Objekt repräsentiert die letzte Version einer Wiki-Seite.
Beispiel
{
"id": 9228,
"key": "Earth",
"title": "Earth",
"latest": {
"id": 963613515,
"timestamp": "2020-06-20T20:05:55Z"
},
"content_model": "wikitext",
"license": {
"url": "//creativecommons.org/licenses/by-sa/3.0/",
"title": "Creative Commons Attribution-Share Alike 3.0"
},
"html_url": "https://en.wikipedia.org/w/rest.php/v1/page/Earth/html"
}
Schema
id
required | integer |
Seitenkennung
|
key
required | string |
Seitentitel in URL-freundlichem Format
|
title
required | string |
Seitentitel in lesefreundlichem Format
|
latest
required | object |
Information über die letzte Version, darunter:
|
content_model
required | string |
Typ des Inhalts der Seite. Siehe die Referenzseite zu Content Handlers für Inhaltsmodelle, die von MediaWiki und Erweiterungen unterstützt werden.
|
license
required | map of strings |
Information über die Lizenz des Wikis, darunter:
|
html_url
required | string (Get page only) |
API-Pfad zum Erhalt des Inhalts der Seite in HTML
|
html
required | string (Nur beim Erhalten einer Seite only) |
|
source
required | string (Nur beim Erhalt einer Quellseite, Erstellung einer Seite und Aktualisierung einer Seite only) |
Letzter Seiteninhalt im Format, das von der Eigenschaft content_model angegeben wird
|
Seitensprachen-Objekt
Das Seitensprachen-Objekt repräsentiert eine Wiki-Seite und ihre Sprache.
Beispiel
{
"code": "pl",
"name": "polski",
"key": "Ziemia",
"title": "Ziemia"
}
Schema
code
required | string |
Sprachcode. Siehe die Seiten-Matrix im Meta-Wiki für Wikimedia-Projekte.
|
name
required | string |
Übersetzter Sprachenname
|
key
required | string |
Übersetzter Seitentitel in URL-freundlichem Format
|
title
required | string |
Übersetzter Seitentitel in lesefreundlichem Format
|
Seite erstellen
Path | /page
|
Method | POST
|
---|---|---|---|
Accepts | application/json
|
Body | see schema below |
Content type | application/json
|
Returns | Seiten-Objekt mit Eigenschaft source
|
Erstellt eine Wiki-Seite. Die Antwort umfasst einen location
-Header, der den API-Endpunkt enthält, um die neue Seite zu erhalten.
Dieser Endpunkt wurde entworfen, um zusammen mit dem Autorisierungsprozess der OAuth-Erweiterung genutzt zu werden. Anrufer, die die Cookie-basierte Authentifizierung nutzen, müssen stattdessen ein CSRF-token
zum Abfragekörper hinzufügen. Um ein CSRF-Token zu erhalten, siehe die Action API.
Beispiele
curl
# Create a user sandbox page on English Wikipedia
$ curl -X POST https://en.wikipedia.org/w/rest.php/v1/page -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" --data '{"source": "Hello, world!", "title": "User:<my username>/Sandbox", "comment": "Creating a test page with the REST API"}'
Python
# Create a user sandbox page on English Wikipedia
import requests
import json
url = 'https://en.wikipedia.org/w/rest.php/v1/page'
# Substitute your OAuth token
headers = {
'User-Agent' : 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)',
'Content-Type' : 'application/json',
'Authorization': 'Bearer $TOKEN'
}
# Substitute your username
request_data = {
"source" : "Hello, world!",
"title" : "User:<my username>/Sandbox",
"comment": "Creating a test page with the REST API"
}
response = requests.post( url, headers=headers, data = json.dumps(request_data) )
output = response.json()
print(output)
PHP
<?php
/*
Create a user sandbox page on English Wikipedia
*/
$url = 'https://en.wikipedia.org/w/rest.php/v1/page';
// Substitute your username
$fields = [
'source' => 'Hello, world!',
'title' => 'User:<my username>/Sandbox',
'comment' => 'Creating a test page with the REST API'
];
$json = json_encode( $fields );
$token = 'YOUR_OAUTH_TOKEN'; // Substitute your OAuth token
$authorization = 'Authorization: Bearer ' . $token;
$ch = curl_init();
curl_setopt( $ch, CURLOPT_URL, $url );
curl_setopt( $ch, CURLOPT_POST, true );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $json );
curl_setopt( $ch, CURLOPT_HTTPHEADER, array( 'Content-Type: application/json' , $authorization ));
curl_setopt( $ch, CURLOPT_USERAGENT, 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)' );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
$output = curl_exec( $ch );
curl_close( $ch );
echo( $output );
?>
JavaScript
/*
Create a user sandbox page on English Wikipedia
Substitute your OAuth token for $TOKEN.
Substitute your username for <my username>.
*/
async function doFetch() {
const response = await fetch(
"https://en.wikipedia.org/w/rest.php/v1/page",
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': 'Bearer $TOKEN'
},
body: JSON.stringify({
"source" : "Hello, world!",
"title" : "User:<my username>/Sandbox",
"comment": "Creating a test page with the REST API"
}),
'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
);
const data = await response.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Abfrage-Schema
source
required | string |
Seiteninhalt im Format, das von der Eigenschaft content_model angegeben wird
|
title
required | string |
Seitentitel. Siehe das Handbuch für Informationen über Seitentitel in MediaWiki. |
comment
required | string |
Grund für die Erstellung der Seite. Um zu erlauben, dass der Kommentar vom Server eingefügt wird, nutze "comment": null ..
|
content_model
optional | string |
Typ des Inhalts der Seite. Standardmäßig wikitext . Siehe die Referenzseite zu Content Handlers für Inhaltsmodelle, die von MediaWiki und Erweiterungen unterstützt werden.
|
token
optional | string |
Zur Nutzung der Cookie-basierten Authentifizierung ist ein CSRF-Token erforderlich. Lasse diese Eigenschaft weg, wenn du OAuth nutzt. |
Antworten
201 | Erfolg: Seite erstellt. Gibt das Seiten-Objekt mit der Eigenschaft source aus.
|
---|---|
400 | token fehlt bei der Nutzung der Cookie-basierten Authentifizierung. Füge ein CSRF-Token zum Abfragekörper hinzu oder nutze den Prozess der OAuth-Autorisierung.
|
400 | Ungültiges Inhaltsmodell. Schließe ein gültiges content_model basierend auf verfügbaren Content-Handlers ein.
|
409 | Seite existiert bereits |
415 | Nicht unterstütztes Inhaltsmodell. Füge den Abfrage-Header Content-Type: application/json hinzu.
|
Eine Seite aktualisieren
Pfad | /page/{title}
|
Inhaltsmodell | application/json
|
---|---|---|---|
Methode | PUT
|
Ausgabe | Seiten-Objekt mit Eigenschaft source
|
Aktualisiert oder erstellt eine Wiki-Seite. Dieser Endpunkt wurde entworfen, um zusammen mit dem Autorisierungsprozess der OAuth-Erweiterung genutzt zu werden. Anrufer, die die Cookie-basierte Authentifizierung nutzen, müssen stattdessen ein CSRF-token
zum Abfragekörper hinzufügen. Um ein CSRF-Token zu erhalten, siehe die Action API.
Du benötigst die Kennung der letzten Version der Seite und die Quellseite. Rufe zunächst den Endpunkt an, um die Quellseite zu erhalten und nutze dann source
und latest.id
, um die Seite zu aktualisieren. Wenn latest.id
nicht mit der letzten Version einer Seite übereinstimmt, löst die API Konflikte automatisch, sofern dies möglich ist. Im Fall eines Bearbeitungskonfliktes, gibt die API einen 409-Fehler aus.
Lasse latest.id
bei der Abfrage weg, um eine Seite zu erstellen.
Beispiele
curl
# Update the sandbox page on English Wikipedia with "Hello, world!"
$ curl -X PUT https://en.wikipedia.org/w/rest.php/v1/page/Wikipedia:Sandbox -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" --data '{"source": "Hello, world!", "comment": "Testing out the REST API", "latest": { "id": 555555555 }}'
Python
# Update the sandbox page on English Wikipedia with "Hello, world!"
import requests
import json
url = "https://en.wikipedia.org/w/rest.php/v1/page/Wikipedia:Sandbox"
# Substitute your OAuth token
headers = {
"User-Agent" : "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)",
"Content-Type" : "application/json",
"Authorization" : "Bearer $TOKEN"
}
# Use the get page endpoint to get the latest revision ID
request_data = {
"source" : "Hello, world!",
"comment": "Testing out the REST API",
"latest" : { "id": 555555555 }
}
response = requests.put( url, headers=headers, data = json.dumps(request_data) )
output = response.json()
print(output)
PHP
<?php
/*
Update the sandbox page on English Wikipedia with "Hello, world!"
*/
$page = 'Wikipedia:Sandbox';
$endpoint = 'https://en.wikipedia.org/w/rest.php/v1/page/';
$url = $endpoint . $page;
// Use the get page endpoint to get the latest revision ID
$fields = [
'source' => 'Hello, world!',
'comment' => 'Testing out the REST API',
'latest' => [
'id' => 555555555
]
];
$json = json_encode( $fields );
$token = 'YOUR_OAUTH_TOKEN'; // Substitute your OAuth token
$authorization = 'Authorization: Bearer ' . $token;
$ch = curl_init();
curl_setopt( $ch, CURLOPT_URL, $url );
curl_setopt( $ch, CURLOPT_CUSTOMREQUEST, 'PUT' );
curl_setopt( $ch, CURLOPT_POSTFIELDS, $json );
curl_setopt( $ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json' , $authorization ));
curl_setopt( $ch, CURLOPT_USERAGENT, 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)' );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
$output = curl_exec( $ch );
curl_close( $ch );
echo( $output );
?>
JavaScript
/*
Update the sandbox page on English Wikipedia with "Hello, world!"
Substitute your OAuth token for $TOKEN.
Use the get page endpoint to get the latest revision ID.
*/
async function doFetch() {
const response = await fetch(
"https://en.wikipedia.org/w/rest.php/v1/page/Wikipedia:Sandbox",
{
method: 'PUT',
headers: {
'Content-Type': 'application/json',
'Authorization': 'Bearer $TOKEN'
},
body: JSON.stringify({
"source": "Hello, world!",
"comment": "Testing out the REST API",
"latest": { "id": 555555555 }
}),
'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
);
const data = await response.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
title
required | path |
Titel der Wiki-Seite |
Abfrage-Schema
source
required | string |
Seiteninhalt im Format, das von der Eigenschaft content_model angegeben wird
|
comment
required | string |
Zusammenfassung der Bearbeitung. Um zu erlauben, dass der Kommentar vom Server eingefügt wird, nutze "comment": null .
|
latest
optional | object |
Objekt, das die Basis-Version der Bearbeitung identifiziert. Du kannst diese Information aus dem Endpunkt zum Erhalt der Quellseite erhalten. |
latest.id
optional | integer |
Identifikator für die Version, die als Basis für die neue source genutzt wird, erfordert die Aktualisierung einer existierenden Seite. Lasse diese Eigenschaft weg, um eine neue Seite zu erstellen.
|
content_model
optional | string |
Typ des Inhalts der Seite. Standardmäßig wikitext für neue Seiten oder das Inhaltsmodell der existierenden Seite. Siehe die Referenzseite zu Content Handlers für Inhaltsmodelle, die von MediaWiki und Erweiterungen unterstützt werden.
|
token
optional | string |
Zur Nutzung der Cookie-basierten Authentifizierung ist ein CSRF-Token erforderlich. Lasse diese Eigenschaft weg, wenn du OAuth nutzt. |
Antworten
200 | Erfolg: Seite aktualisiert. Gibt das Seiten-Objekt mit der Eigenschaft source aus.
|
---|---|
201 | Erfolg: Seite aktualisiert. Gibt das Seiten-Objekt mit der Eigenschaft source aus.
|
400 | token fehlt bei der Nutzung der Cookie-basierten Authentifizierung. Füge ein CSRF-Token zum Abfragekörper hinzu oder nutze den Prozess der OAuth-Autorisierung.
|
400 | Ungültiges Inhaltsmodell. Stelle sicher, dass die Eigenschaft content_model im Abfragekörper mit dem content_model der Zielseite übereinstimmt.
|
409 | Seite existiert bereits. Gib die Kennung der grundlegenden Version in latest.id im Abfragekörper an, um die existierende Seite zu aktualisieren.
|
409 | Bearbeitungskonflikt. Der Fehler enthält die Unterschiede zwischen der in der Abfrage angegebenen grundlegenden Version und der letzten veröffentlichten Version. Siehe die Wikidiff2-Dokumentation für Informationen über das Format des Versionsunterschieds. Erfordert die Wikidiff2-Erweiterung 1.10+. |
415 | Nicht unterstütztes Inhaltsmodell. Füge den Abfrage-Header Content-Type: application/json hinzu.
|
Seite erhalten
Pfad | /page/{title}/bare
|
Inhaltsmodell | application/json
|
---|---|---|---|
Methode | GET
|
Ausgabe | Seiten-Objekt mit Eigenschaft html_url
|
Gibt das Standard-Seiten-Objekt für eine Wiki-Seite mit dem API-Pfad zum Erhalt des letzten Inhalts in HTML, der Lizenz und Informationen über die letzte Version aus.
Beispiele
curl
# Get information about the Jupiter article on English Wikipedia
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/bare"
Python
# Get information about the Jupiter article on English Wikipedia
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/bare'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Get information about the Jupiter article on English Wikipedia
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/bare";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get information about the Jupiter article on English Wikipedia
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/bare";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
title
required | path |
Titel der Wiki-Seite |
Antworten
200 | Erfolg: Seite gefunden. Gibt die Seite mit der Eigenschaft html_url aus.
|
---|---|
301 | |
404 | Titel oder Version nicht gefunden |
Seite offline erhalten
Pfad | /page/{title}/with_html
|
Inhaltsmodell | application/json
|
---|---|---|---|
Methode | GET
|
Ausgabe | Seiten-Objekt mit Eigenschaft html
|
Gibt Informationen über eine Wiki-Seite aus, darunter die Lizenz, die letzte Version und der letzte Inhalt in HTML.
Beispiele
curl
# Get HTML and metadata for the Jupiter article on English Wikipedia
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/with_html"
Python
# Get HTML and metadata for the Jupiter article on English Wikipedia
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/with_html'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Get HTML and metadata for the Jupiter article on English Wikipedia
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/with_html";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get HTML and metadata for the Jupiter article on English Wikipedia
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/with_html";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
title
required | path | string |
Titel der Wiki-Seite |
redirect
optional | query | bool |
Antworten
200 | |
---|---|
301 | |
307 | |
404 |
Quellseite erhalten
Pfad | /page/{title}
|
Inhaltsmodell | application/json
|
---|---|---|---|
Methode | GET
|
Ausgabe | Seiten-Objekt mit Eigenschaft source
|
Gibt den Inhalt einer Wiki-Seite im durch die Eigenschaft content_model
angegebenen Format, die Lizenz und Informationen über die letzte Version aus.
Beispiele
curl
# Get source and metadata for the Jupiter article on English Wikipedia
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter"
Python
# Get source and metadata for the Jupiter article on English Wikipedia
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Get source and metadata for the Jupiter article on English Wikipedia
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get source and metadata for the Jupiter article on English Wikipedia
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
title
required | path |
Titel der Wiki-Seite |
Antworten
200 | |
---|---|
301 | |
404 |
HTML erhalten
Pfad | /page/{title}/html
|
Inhaltsmodell | text/html
|
---|---|---|---|
Methode | GET
|
Ausgabe | Seiten-HTML im HTML-2.1.0-Format |
Gibt den letzten Inhalt einer Wiki-Seite in HTML aus.
Beispiele
curl
# Get the content of the Jupiter article on English Wikipedia in HTML
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/html"
Python
# Get the content of the Jupiter article on English Wikipedia in HTML
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/html'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Get the content of the Jupiter article on English Wikipedia in HTML
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/html";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get the content of the Jupiter article on English Wikipedia in HTML
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/html";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
title
required | path | string |
|
redirect
optional | query | bool |
Antworten
200 | |
---|---|
301 | |
307 | |
404 |
Sprachen erhalten
Pfad | /page/{title}/links/language
|
Inhaltsmodell | application/json
|
---|---|---|---|
Methode | GET
|
Ausgabe | Array von Seitensprachen |
Durchsucht verbundene Wikis nach Seiten mit dem gleichen Thema in einer anderen Sprache. Gibt ein Array der Seitensprachen-Objekte aus, das den Namen der Sprache, den Sprachcode und den übersetzten Seitentitel enthält. Returns an array of page language objects that include the name of the language, the language code, and the translated page title.
Beispiele
curl
# Find articles from other Wikipedias linked to the Jupiter article on English Wikipedia
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/language"
Python
# Find articles from other Wikipedias linked to the Jupiter article on English Wikipedia
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/language'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Find articles from other Wikipedias linked to the Jupiter article on English Wikipedia
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/language";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Find articles from other Wikipedias linked to the Jupiter article on English Wikipedia
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/language";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
title
required | path |
Titel der Wiki-Seite |
Antworten
200 | Erfolg: Sprachen gefunden. Gibt ein Array der Seitensprachen aus. |
---|---|
404 | Titel nicht gefunden |
Dateien von einer Seite erhalten
Pfad | /page/{title}/links/media
|
Inhaltsmodell | application/json
|
---|---|---|---|
Methode | GET
|
Ausgabe | files -Objekt, das das Array der Dateien enthält
|
Gibt Informationen über Mediendateien aus, die auf einer Wiki-Seite genutzt werden.
Beispiele
curl
# Get media files used on the Jupiter article on English Wikipedia
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/media"
Python
# Get media files used on the Jupiter article on English Wikipedia
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/media'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Get media files used on the Jupiter article on English Wikipedia
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/media";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get media files used on the Jupiter article on English Wikipedia
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/links/media";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
title
required | path |
Titel der Wiki-Seite |
Antworten
200 | Erfolg: Mediendateien gefunden. Gibt ein files -Objekt aus, das ein Array der Dateien enthält.
|
---|---|
200 | Erfolg: Keine Mediendateien gefunden. Gibt ein files -Objekt aus, das ein leeres Array enthält.
|
404 | Titel nicht gefunden |
400 | Seite enthält mehr als 100 Mediendateien |
Transform
MediaWiki Version: | ≥ 1.41 |
The transform endpoint provides on-the-fly round-trip conversion between wikitext and HTML.
Convert Wikitext to HTML
Pfad | /transform/wikitext/to/html/{title}
|
Content type | application/json
|
---|---|---|---|
Methode | POST
|
Payload | Transform request body with source
|
Returns | an HTML document. |
Converts wikitext to HTML.
Examples
curl
# Render wikitext in the context of the Jupiter page on English Wikipedia, without modifying the page:
$ curl -X POST -H "Content-Type: application/json" --data '{ "wikitext": "== Hello Jupiter ==" }' 'https://en.wikipedia.org/w/rest.php/v1/transform/wikitext/to/html/Jupiter'
Parameters
title
required | path |
Wiki page title, used for context |
Responses
200 | Success: the response body contains the rendered HTML. |
---|
Convert HTML to Wikitext
Pfad | /transform/html/to/wikitext/{title}
|
Content type | application/json
|
---|---|---|---|
Methode | POST
|
Payload | Transform request body with HTML
|
Returns | a wikitext document. |
Converts wikitext to HTML.
Beispiele
curl
# Generate wikitext from HTML, in the context of the Jupiter page on English Wikipedia:
$ curl -X POST -H "Content-Type: application/json" --data '{ "html": "<h2> hello World </h2>" }' 'https://en.wikipedia.org/w/rest.php/v1/transform/html/to/wikitext/Jupiter'
Parameter
title
required | path |
Wiki page title, used for context |
Antworten
200 | Success: the response body contains the wikitext. |
---|
Transform request body
Payload structure for transform requests.
Example
For converting wikitext to HTML:
{
"wikitext": "Hello World"
}
For converting HTML to Wikitext:
{
"html": "<h2>Hello World</h2>"
}
Mediendateien
MediaWiki Version: | ≥ 1.35 |
Datei-Objekt
Das Datei-Objekt repräsentiert eine Datei, die in einem Wiki hochgeladen wurde.
Beispiel
{
"title": "The Blue Marble.jpg",
"file_description_url": "//commons.wikimedia.org/wiki/File:The_Blue_Marble.jpg",
"latest": {
"timestamp": "2011-12-07T05:11:41Z",
"user": {
"id": 811185,
"name": "Ultimate Roadgeek"
}
},
"preferred": {
"mediatype": "BITMAP",
"size": null,
"width": 599,
"height": 599,
"duration": null,
"url": "https://upload.wikimedia.org/wikipedia/commons/thumb/7/78/The_Blue_Marble.jpg/599px-The_Blue_Marble.jpg"
},
"original": {
"mediatype": "BITMAP",
"size": 7011595,
"width": 3000,
"height": 3002,
"duration": null,
"url": "https://upload.wikimedia.org/wikipedia/commons/7/78/The_Blue_Marble.jpg"
},
"thumbnail": {
"mediatype": "BITMAP",
"size": null,
"width": 1023,
"height": 1024,
"duration": null,
"url": "https://upload.wikimedia.org/wikipedia/commons/thumb/7/78/The_Blue_Marble.jpg/1023px-The_Blue_Marble.jpg"
}
}
Schema
title
required | string |
Dateititel |
file_description_url
required | string |
URL für die Seite, die die Datei beschreibt, inklusive Lizenzinformationen und anderen Metadaten |
latest
required | object |
Objekt, das Informationen über die letzte Version der Datei enthält, darunter:
|
preferred
required | object |
Informationen über das bevorzugte Vorschauformat der Datei, das originale Format und das Miniaturformat, darunter:
|
original
required | object | |
Nur beim Erhalten einer Datei
required | object |
Datei erhalten
Pfad | /file/{title}
|
Inhaltsmodell | application/json
|
---|---|---|---|
Methode | GET
|
Ausgabe | Datei |
Gibt Informationen über eine Datei aus, darunter Links zum Herunterladen der Datei im Miniaturformat, Vorschauformat und originalen Format.
Beispiele
curl
# Get File:The_Blue_Marble.jpg on Wikimedia Commons
$ curl "https://en.wikipedia.org/w/rest.php/v1/file/File:The_Blue_Marble.jpg"
Python
# Get File:The_Blue_Marble.jpg on Wikimedia Commons
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/file/File:The_Blue_Marble.jpg'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Get File:The_Blue_Marble.jpg on Wikimedia Commons
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/file/File:The_Blue_Marble.jpg";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get File:The_Blue_Marble.jpg on Wikimedia Commons
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/file/File:The_Blue_Marble.jpg";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
Parameter | Beschreibung |
---|---|
title
required | path |
Dateititel |
Antworten
200 | Erfolg: Datei gefunden. Gibt die Datei aus. |
---|---|
404 | Titel nicht gefunden |
Versionsgeschichte
MediaWiki Version: | ≥ 1.35 |
Versionsobjekt
Das Versionsobjekt repräsentiert eine Änderung auf einer Wiki-Seite.
Beispiel
{
"id": 931281281,
"page": {
"id": 38930,
"title": "Jupiter"
},
"size": 126009,
"minor": false,
"timestamp": "2019-12-18T01:39:24Z",
"user": {
"id": 27015025,
"name": "InternetArchiveBot"
},
"comment": "Bluelinking 2 books for [[WP:V|verifiability]].) #IABot (v2.1alpha3",
"delta": 231
}
Schema
id
required | integer |
Versionsidentifikator |
Nur beim Erhalten einer Version
required | object |
Objekt, das Informationen über die Seite enthält, darunter:
|
user
required | object |
Objekt, das Informationen über den Benutzer enthält, der die Bearbeitung vorgenommen hat, darunter:
Für unangemeldete Benutzer enthält |
timestamp
required | string |
Zeitstempel der Bearbeitung im Format ISO 8601 |
comment
required | string |
Kommentar oder Bearbeitungszusammenfassung des Autors. Für Versionen ohne einen Kommentar gibt die API null oder "" aus.
|
size
required | integer |
Größe der Version in Bytes |
delta
required | integer |
Anzahl der geänderten Bytes, positiv oder negativ, zwischen einer Version und der älteren Version (Beispiel: -20 ). Wenn die ältere Version nicht verfügbar ist, gibt die API null aus.
|
minor
required | boolean |
true für Bearbeitungen, die als klein markiert wurden |
html_url
required | string (Get revision only) |
|
html
required | string (Get revision with HTML only) |
|
source
required | string (Get revision source only) |
|
Versionsgeschichte erhalten
Pfad | /page/{title}/history
|
Inhaltsmodell | application/json
|
---|---|---|---|
Methode | GET
|
Ausgabe | Bereich der Versionsgeschichte |
Gibt Informationen über die letzten Versionen einer Wiki-Seite in Bereichen von 20 Versionen, beginnend mit der letzten Version, aus. Die Antwort enthält API-Pfade für die nächstälteren, nächstneueren und die neuesten Versionsbereiche und ermöglicht es dir so, durch die Versionsgeschichte zu scrollen.
Beispiele
curl
# Get revisions made to the Jupiter article on English Wikipedia by bots prior to revision 939967546
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history?filter=bot&older_than=939967546"
Python
# Get revisions made to the Jupiter article on English Wikipedia by bots prior to revision 939967546
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
params = {
'filter': 'bot',
'older_than': '939967546'
}
response = requests.get(url, headers=headers, params=params)
data = response.json()
print(data)
PHP
<?php
/*
Get revisions made to the Jupiter article on English Wikipedia by bots prior to revision 939967546
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history";
$params = [ "filter" => "bot", "older_than" => "939967546" ];
$url = $url . "?" . http_build_query( $params );
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get revisions made to the Jupiter article on English Wikipedia by bots prior to revision 939967546
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
let params = {
'filter': 'bot',
'older_than': '939967546'
};
let query = Object.keys(params)
.map(k => k + '=' + encodeURIComponent(params[k]))
.join('&');
url = url + '?' + query;
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
title
required | path |
Titel der Wiki-Seite |
older_than
optional | query |
Akzeptiert eine Versionskennung. Gibt die 20 nächstälteren Versionen der angegebenen Versionskennung aus. |
newer_than
optional | query |
Akzeptiert eine Versionskennung. Gibt die 20 nächstneueren Versionen der angegebenen Versionskennung aus. |
filter
optional | query |
Filter, der nur Versionen mit bestimmten Markierungen ausgibt. Eine von:
Die API unterstützt einen Filter je Abfrage. |
Antworten
200 | Erfolg: Versionen gefunden. Gibt einen Bereich der Versionsgeschichte aus. |
---|---|
200 | Erfolg: Keine Versionen gefunden. Gibt einen Bereich der Versionsgeschichte mit einem leeren Array revisions aus.
|
400 | Versionskennung muss größer als 0 sein |
400 | Die Parameter older_than und newer_than können nicht beide zusammen angegeben werden
|
400 | Ungültiger Parameter |
404 | Titel oder Version nicht gefunden |
Antwort-Schema
latest
required | string |
API-Pfad, um die letzten Versionen zu erhalten |
older
optional | string |
API-Pfad zum Erhalt der älteren Versionen, sofern verfügbar |
newer
optional | string |
API-Pfad zum Erhalt der neueren Versionen, sofern verfügbar |
revisions
required | array |
Array von 0-20 Versionsobjekten |
Versionszähler erhalten
Pfad | /page/{title}/history/counts/{type}
|
Inhaltsmodell | application/json
|
---|---|---|---|
Methode | GET
|
Ausgabe | Versionszähler-Objekt |
Gibt Daten über die Versionsgeschichte einer Seite aus.
Beispiele
curl
# Get the number of edits to a page between revisions 384955912 and 406217369
$ curl "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history/counts/edits?from=384955912&to=406217369"
Python
# Get the number of edits to a page between revisions 384955912 and 406217369
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history/counts/edits'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
params = {
'from': '384955912',
'to': '406217369'
}
response = requests.get(url, headers=headers, params=params)
data = response.json()
print(data)
PHP
<?php
/*
Get the number of edits to a page between revisions 384955912 and 406217369
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history/counts/edits";
$params = [ "from" => "384955912", "to" => "406217369" ];
$url = $url . "?" . http_build_query( $params );
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get the number of edits to a page between revisions 384955912 and 406217369
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/page/Jupiter/history/counts/edits";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
let params = {
'from': '384955912',
'to': '406217369'
};
let query = Object.keys(params)
.map(k => k + '=' + encodeURIComponent(params[k]))
.join('&');
url = url + '?' + query;
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
title
required | path |
Titel der Wiki-Seite |
type
required | path |
Typ des Zählers. Einer von:
|
from
optional | query |
Nur für die Typen edits und editors
Begrenzt den Zähler zwischen zwei Versionen, angegeben durch Versionskennungen. Die Abfrageparameter |
to
optional | query |
Antworten
200 | Erfolg |
---|---|
400 | Ungültiger Parameter oder Kombination von Parametern |
404 | Titel oder Version nicht gefunden |
500 | Zähler kleiner Bearbeitungen übersteigt 2.000 |
Antwort-Schema
count
required | integer |
Der Wert des Datenpunktes bis zum Limit des Typs. Wenn der Wert das Limit übersteigt, gibt die API das Limit als Wert von count aus und setzt die Eigenschaft limit auf true.
|
limit
required | boolean |
Gibt true aus, wenn der Datenpunkt das Limit des Typs übersteigt. |
Version erhalten
Path | revision/{id}/bare
|
Method | GET
|
---|---|---|---|
Content type | application/json
|
Returns | Version |
Gibt Details für eine einzelne Version aus.
Beispiele
curl
# Get information about revision 764138197
$ curl "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/bare"
Python
# Get information about revision 764138197
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/revision/764138197/bare'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Get information about revision 764138197
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/bare";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get information about revision 764138197
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/bare";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
id
required | path | string |
Versionskennung |
Antworten
200 | Erfolg: Version gefunden. Gibt eine Version aus. |
---|---|
404 |
Get revision source
Path | revision/{id}
|
Method | GET
|
---|---|---|---|
Content type | application/json
|
Returns | Revision |
Returns details for an individual revision.
Examples
curl
# Get the wikitext of revision 764138197
$ curl "https://en.wikipedia.org/w/rest.php/v1/revision/764138197"
Python
# Get the wikitext of revision 764138197
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/revision/764138197'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Get the wikitext of revision 764138197
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get the wikitext of revision 764138197
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameters
id
required | path | string |
Responses
200 | |
---|---|
404 | Version nicht gefunden |
Get revision HTML
Path | revision/{id}/html
|
Method | GET
|
---|---|---|---|
Content type | text/HTML
|
Returns | Revision |
Returns HTML for an individual revision.
Examples
curl
# Get HTML of revision 764138197
$ curl "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/html"
Python
# Get HTML of revision 764138197
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/revision/764138197/html'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Get HTML of revision 764138197
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/html";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get HTML of revision 764138197
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/html";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameters
id
required | path | string |
Responses
200 | |
---|---|
404 |
Get revision information with HTML
Path | revision/{id}/with_html
|
Method | GET
|
---|---|---|---|
Content type | application/json
|
Returns | Revision |
Returns HTML and meta-data for an individual revision.
Examples
curl
# Get information about revision 764138197 along with rendered HTML
$ curl "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/with_html"
Python
# Get information about revision 764138197 along with rendered HTML
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/revision/764138197/with_html'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Get information about revision 764138197 along with rendered HTML
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/with_html";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Get information about revision 764138197 along with rendered HTML
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/revision/764138197/with_html";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameters
id
required | path | string |
Responses
200 | |
---|---|
404 |
Versionen vergleichen
Pfad | revision/{from}/compare/{to}
|
Inhaltsmodell | application/json
|
---|---|---|---|
Methoden | GET
|
Ausgabe | Wikidiff2-JSON-Versionsunterschiedsformat |
Gibt Daten aus, die dich Zeile für Zeile zwei Versionen vergleichen lassen. (Siehe ein Beispiel.) Nur textbasierte Wiki-Seiten können verglichen werden.
Installiere Wikidiff2 1.9.0 oder neuer.
Beispiele
curl
# Compare revision 847170467 to 851733941
$ curl "https://en.wikipedia.org/w/rest.php/v1/revision/847170467/compare/851733941"
Python
# Compare revision 847170467 to 851733941
import requests
url = 'https://en.wikipedia.org/w/rest.php/v1/revision/847170467/compare/851733941'
headers = {
'User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'
}
response = requests.get(url, headers=headers)
data = response.json()
print(data)
PHP
<?php
/*
Compare revision 847170467 to 851733941
*/
$url = "https://en.wikipedia.org/w/rest.php/v1/revision/847170467/compare/851733941";
$ch = curl_init( $url );
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
curl_setopt( $ch, CURLOPT_USERAGENT, "MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)" );
$output = curl_exec( $ch );
curl_close( $ch );
echo($output);
?>
JavaScript
/*
Compare revision 847170467 to 851733941
*/
async function doFetch() {
let url = "https://en.wikipedia.org/w/rest.php/v1/revision/847170467/compare/851733941";
let headers = {'Api-User-Agent': 'MediaWiki REST API docs examples/0.1 (https://www.mediawiki.org/wiki/API_talk:REST_API)'}
const rsp = await fetch(url, headers);
const data = await rsp.json();
return data;
}
async function fetchAsync()
{
try {
let result = await doFetch();
console.log(result);
} catch( err ) {
console.error( err.message );
}
}
fetchAsync();
Parameter
from
required | path |
Versionskennung, die als Basis für den Vergleich dient |
to
required | path |
Versionskennung, mit der die Basis verglichen werden soll |
Antworten
200 | Erfolg: Versionen gefunden |
---|---|
400 | Versionskennungen beziehen sich auf unterschiedliche Seiten oder auf Seiten, die nicht verglichen werden können |
400 | Ungültiges Inhaltsmodell |
403 | Version nicht öffentlich zugänglich |
404 | Version nicht gefunden |
500 | Wikidiff2-Erweiterung 1.9.0 oder neuer nicht installiert |
Antwort-Schema
from
required | object |
Information über die Basis-Version, die im Vergleich genutzt wird |
to
required | object |
Information über die Version, die mit der Basis-Version verglichen wird |
from.id
|
Versionsidentifikator |
from.slot_role
|
Bereich der Seite, der verglichen wird, normalerweise main
|
from.sections
|
Array von Objekten, die Abschnittsüberschriften repräsentieren, darunter:
|
diff
required | array of objects |
Each object in the diff array represents a line in a visual, line-by-line comparison between the two revisions.
|
diff.type
required | integer |
The type of change represented by the diff object, either:
|
diff.lineNumber
optional | integer |
The line number of the change based on the to revision.
|
diff.text
required | string |
The text of the line, including content from both revisions. For a line containing text that differs between the two revisions, you can use highlightRanges to visually indicate added and removed text. For a line containing a new line, the API returns the text as "" (empty string).
|
diff.highlightRanges
optional | array of objects |
An array of objects that indicate where and in what style text should be highlighted to visually represent changes.
Each object includes:
|
diff.moveInfo
optional | object |
Visual indicators to use when a paragraph's location differs between the two revisions. moveInfo objects occur in pairs within the diff.
|
diff.offset
required | object |
The location of the line in bytes from the beginning of the page, including:
|